{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5b2ac00e-c7fc-45cc-888e-8c26dabf80d2",
   "metadata": {},
   "source": [
    "# Readout Error Mitigation\n",
    "\n",
    "Readout errors are caused by imperfect qubit measurement and are a common source of error in quantum computing. Properly modelling these errors in simulation can give the user tools to understand better what these errors are and how to mitigate them when running on actual quantum devices.\n",
    "\n",
    "Readout errors can be mitigated with a confusion matrix $A$. It is a square matrix of size $2^n \\times 2^n$ and tells about the probability of observing the state $|y\\rangle$ given the true state $|x\\rangle$. The confusion matrix characterizes the readout error of the device and is circuit-independent. Once $A$ is estimated, we can compute its pseudoinverse $A^+$ which can be applied to the noisy probability distribution $p_{\\text{noisy}}$ to obtain an adjusted quasi-probability distribution \n",
    "\n",
    "$$\n",
    "p_{\\text{mitigated}} = A^+ p_{\\text{noisy}}\n",
    "$$\n",
    "\n",
    "In this tutorial, we show how to build a confusion matrix with the following approaches.\n",
    "\n",
    "- Using a  single qubit model\n",
    "- Using $k$ local confusion matrices\n",
    "- A full confusion matrix for each $2^n$ combination\n",
    "\n",
    "The last method works well for correcting correlated errors (which affect multiple qubits together). However, it becomes impractical for large numbers of qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "04b58854-7dab-4f1b-8c59-d8b9506bce44",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install the relevant packages.\n",
    "\n",
    "!pip install matplotlib==3.8.4 pandas==2.2.2 scipy==1.13.1 seaborn==0.13.2 -q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "710a2a46-4e55-4508-a0b7-21969aac6a87",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cudaq\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import itertools\n",
    "from functools import reduce\n",
    "from scipy.optimize import minimize\n",
    "from typing import Union\n",
    "\n",
    "sns.set_style(\"dark\")\n",
    "\n",
    "cudaq.set_target(\"density-matrix-cpu\")\n",
    "seed = 42\n",
    "\n",
    "cudaq.set_random_seed(seed)\n",
    "np.random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eab761a-0a82-4e20-8cf8-54602cd05d6a",
   "metadata": {},
   "source": [
    "To model the readout error, we apply a bitflip channel on every qubit at the end of the circuit using an Identity gate. The probability of bitflip `probs` can be the same or different for all the qubits.\n",
    "\n",
    "<div class=\"alert alert-block alert-success\"><b>Note: </b>\n",
    "In principle, readout error is applied to the measurement gate but we use the Identity gate because adding a quantum error on the measurement gate is not yet supported. Also, the Identity gate is not present in the <kbd>add_channel</kbd> method, so we model the Identity gate using a rotation gate with an angle of 0.0.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d84bb420-4fab-4c26-919a-7efa8d3a219b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_noise(n_qubits: int, probs: Union[float, list[float]]):\n",
    "    \"\"\"\n",
    "    Creates a noise model with specified probabilities of bit flip errors on each qubit.\n",
    "\n",
    "    Args:\n",
    "        n_qubits (int): The number of qubits in the quantum circuit.\n",
    "        probs (Union[float, list[float]]): Probabilities of a bit flip error occurring on each qubit.\n",
    "        If a single probability value is provided, it will be applied to all qubits. If a list of\n",
    "        probabilities is provided, each qubit will have its own probability.\n",
    "\n",
    "    Returns:\n",
    "        cudaq noise model\n",
    "    \"\"\"\n",
    "    noise = cudaq.NoiseModel()\n",
    "\n",
    "    if not isinstance(probs, list):\n",
    "        probs = [probs] * n_qubits\n",
    "\n",
    "    for i, p in enumerate(probs):\n",
    "        bit_flip = cudaq.BitFlipChannel(p)\n",
    "        noise.add_channel(\"rx\", [i], bit_flip)\n",
    "\n",
    "    return noise"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb4c7a14-1c0c-4fab-a6aa-7174c23baa7f",
   "metadata": {},
   "source": [
    "We define a cudaq kernel which will help create a set of quantum circuits to take measurements of the basis states for $n$ qubits. The kernel takes the number of qubits and the basis state as arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "53e3f450-000f-49b8-ad5c-57aa74461694",
   "metadata": {},
   "outputs": [],
   "source": [
    "@cudaq.kernel\n",
    "def kernel(n_qubits: int, state_label: list[int]):\n",
    "    qvector = cudaq.qvector(n_qubits)\n",
    "    for i, val in enumerate(state_label):\n",
    "        if val == 1:\n",
    "            x(qvector[i])\n",
    "        rx(0.0, qvector[i]\n",
    "          )  # Identity gate at the end on each qubit to model readout error\n",
    "    mz(qvector)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95411463-cd1e-499f-baef-d624acc0122c",
   "metadata": {},
   "source": [
    "For the tutorial, we will use the GHZ state on three qubits to test readout error mitigation. The GHZ state on 3 qubits is described as:\n",
    "\n",
    "$$\n",
    "\\frac{|000\\rangle + |111\\rangle}{\\sqrt{2}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c1476028-923d-4f2b-b5fc-39ebcc8cbab9",
   "metadata": {},
   "outputs": [],
   "source": [
    "@cudaq.kernel\n",
    "def ghz_kernel(n_qubits: int):\n",
    "    qvector = cudaq.qvector(n_qubits)\n",
    "\n",
    "    h(qvector[0])\n",
    "    for i in range(n_qubits - 1):\n",
    "        cx(qvector[i], qvector[i + 1])\n",
    "\n",
    "    # Apply identity gates for readout error mitigation\n",
    "    for i in range(n_qubits):\n",
    "        rx(0.0, qvector[i])\n",
    "\n",
    "    mz(qvector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "900d2110-d613-426a-8aa9-6c12b1238536",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to draw the confusion matrix\n",
    "def plot_cmat(mat):\n",
    "    fig, ax = plt.subplots()\n",
    "    n = len(mat)\n",
    "    im2 = ax.matshow(mat, cmap=plt.cm.Reds, vmin=0, vmax=1.0)\n",
    "    ax.set_yticks(np.arange(n))\n",
    "    ax.set_xticks(np.arange(n))\n",
    "    ax.set_yticklabels(n * [\"\"])\n",
    "    ax.set_xticklabels(n * [\"\"])\n",
    "    ax.set_title(r\"Confusion Matrix\", fontsize=16)\n",
    "    ax.set_xlabel(\"Prepared State\")\n",
    "    ax.xaxis.set_label_position(\"top\")\n",
    "    ax.set_ylabel(\"Measured State\")\n",
    "    fig.colorbar(im2, ax=ax)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "032f6898-c953-4d30-a2bf-e8b46ee77c62",
   "metadata": {},
   "source": [
    "It is possible that the adjusted quasi-probability distribution $p_{\\text{mitigated}}$ obtained by application of $A^+$ to $p_{\\text{noisy}}$ may be non-positive. We need to find the closest positive probability distribution in such a case.\n",
    "\n",
    " $$ p'' = \\min_{p_{\\rm positive}} \\|p_{\\rm noisy} - p_{\\rm positive}\\|_1$$\n",
    "\n",
    "Then, we can draw samples from $p''$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9b355dcb-bf80-42a1-ae11-dcc9f11ba1e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_closest_distribution(empirical_dist):\n",
    "    \"\"\"\n",
    "    Find the closest distribution to an empirical distribution by minimizing the L1 norm.\n",
    "\n",
    "    Args:\n",
    "        empirical_dist: Empirical distribution that you want to find the closest distribution to.\n",
    "\n",
    "    Returns:\n",
    "        Closest distribution to `empirical_dist`\n",
    "    \"\"\"\n",
    "\n",
    "    def objective(x):\n",
    "        return np.linalg.norm(empirical_dist - x, ord=1)\n",
    "\n",
    "    # Constraint: all elements of p must be positive, and the distribution must sum to 1\n",
    "    cons = (\n",
    "        {\n",
    "            \"type\": \"ineq\",\n",
    "            \"fun\": lambda p: p\n",
    "        },\n",
    "        {\n",
    "            \"type\": \"eq\",\n",
    "            \"fun\": lambda p: np.sum(p) - 1\n",
    "        },\n",
    "    )\n",
    "    bnds = [(0, 1) for _ in range(len(empirical_dist))]\n",
    "    initial_value = np.random.uniform(size=len(empirical_dist))\n",
    "\n",
    "    res = minimize(\n",
    "        objective,\n",
    "        initial_value,\n",
    "        method=\"SLSQP\",\n",
    "        options={\"maxiter\": 1000},\n",
    "        bounds=bnds,\n",
    "        constraints=cons,\n",
    "    )\n",
    "\n",
    "    return res.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0ceb5a15-cecf-47ed-b1cc-cea79fa936f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_counts_from_distribution(n_qubits, size, dist):\n",
    "    \"\"\"\n",
    "    Generates samples based on a given distribution and returns the counts of each sample value.\n",
    "\n",
    "    Args:\n",
    "        n_qubits: The number of qubits in the quantum circuit.\n",
    "        dist: The probability distribution from which samples are drawn.\n",
    "\n",
    "    Returns:\n",
    "        An array of counts for each possible value in the distribution. The array has a length of 2^n_qubits.\n",
    "    \"\"\"\n",
    "    samples = np.random.choice(np.arange(2**n_qubits), size=size, p=dist)\n",
    "    values, counts = np.unique(samples, return_counts=True)\n",
    "    res = np.zeros(2**n_qubits, dtype=int)\n",
    "    res[values] = counts\n",
    "    return res"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1225d4de-fcc8-4a56-846b-44d6a52a272f",
   "metadata": {},
   "source": [
    "Let's run the `ghz_kernel` with the noise model. We will perform two experiments. First, we keep the bitflip probability the same for all the qubits. In the second experiment, we use different bitflip probabilities for qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "53453484-a8d5-416c-8aad-7c982cad7191",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_qubits = 3\n",
    "shots = 1024\n",
    "\n",
    "labels = list(map(list, itertools.product([0, 1], repeat=n_qubits)))\n",
    "states = list(map(lambda label: \"\".join(map(str, label)), labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2d147fe7-ce5e-475c-9014-59d4ff63a644",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bitflip probability: 0.1\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'000': 352,\n",
       " '010': 43,\n",
       " '111': 367,\n",
       " '001': 47,\n",
       " '011': 47,\n",
       " '100': 54,\n",
       " '101': 61,\n",
       " '110': 53}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = 0.1\n",
    "print(f\"bitflip probability: {p}\\n\")\n",
    "\n",
    "noise_1 = get_noise(n_qubits, p)\n",
    "\n",
    "ghz_result = cudaq.sample(ghz_kernel,\n",
    "                          n_qubits,\n",
    "                          shots_count=shots,\n",
    "                          noise_model=noise_1)\n",
    "noisy_dict_1 = dict(list(ghz_result.items()))\n",
    "\n",
    "noisy_res_1 = np.array(\n",
    "    [noisy_dict_1.get(state, 0) for i, state in enumerate(states)])\n",
    "\n",
    "noisy_dict_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "976f13da-277b-4754-9a58-277a5988f739",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bitflip probability: [0.149816047538945, 0.3802857225639665, 0.292797576724562]\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'000': 212,\n",
       " '010': 122,\n",
       " '111': 189,\n",
       " '001': 111,\n",
       " '011': 87,\n",
       " '100': 78,\n",
       " '101': 131,\n",
       " '110': 94}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = list(np.random.uniform(low=0.0, high=0.4, size=n_qubits))\n",
    "print(f\"bitflip probability: {p}\\n\")\n",
    "\n",
    "noise_2 = get_noise(n_qubits, p)\n",
    "\n",
    "ghz_result = cudaq.sample(ghz_kernel,\n",
    "                          n_qubits,\n",
    "                          shots_count=shots,\n",
    "                          noise_model=noise_2)\n",
    "noisy_dict_2 = dict(list(ghz_result.items()))\n",
    "\n",
    "noisy_res_2 = np.array(\n",
    "    [noisy_dict_2.get(state, 0) for i, state in enumerate(states)])\n",
    "\n",
    "noisy_dict_2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1889f50a-f051-4f0e-bace-18477122eafe",
   "metadata": {},
   "source": [
    "## Inverse confusion matrix from single-qubit noise model\n",
    "\n",
    "Here we assume that the readout error of each qubit is independent with the same confusion probabilities. Then, the confusion matrix $A_1$ for a single qubit can be defined as\n",
    "\n",
    "$$\n",
    "A_1 = \\begin{bmatrix}\n",
    "P(0|0) & P(0|1)\\\\\n",
    "P(1|0) & P(1|1)\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "where $P(y|x)$ is the probability of observing state $|y\\rangle$ when measuring the true state $|x\\rangle$. Using $A_1$, the full $2^n \\times 2^n$ confusion matrix $A$ can be written as \n",
    "\n",
    "$$\n",
    "A = A_1 \\otimes \\dots \\otimes A_1\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e6ceb0a9-c2ec-4fcd-bb23-457890a8b57e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 becomes {'0': 924, '1': 100}\n",
      "1 becomes {'0': 104, '1': 920}\n"
     ]
    }
   ],
   "source": [
    "single_qubit_labels = [[0], [1]]\n",
    "single_qubit_states = [\"0\", \"1\"]  # Used for dictionary keys\n",
    "\n",
    "# we use noise_1 which has same bitflip probability for all qubits\n",
    "results = [\n",
    "    cudaq.sample(kernel, 1, label, shots_count=shots, noise_model=noise_1)\n",
    "    for label in single_qubit_labels\n",
    "]\n",
    "\n",
    "for i, state in enumerate(single_qubit_states):\n",
    "    res = dict(list(results[i].items()))\n",
    "    print(f\"{state} becomes {res}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9f030f99-0ad9-4f89-8d99-a570b3c5e745",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.90234375 0.1015625 ]\n",
      " [0.09765625 0.8984375 ]]\n"
     ]
    }
   ],
   "source": [
    "# Construct confusion matrix for single qubit\n",
    "\n",
    "A_1 = np.zeros((2, 2))\n",
    "for i, state in enumerate(single_qubit_states):\n",
    "    true_state = int(state, 2)\n",
    "    for key, val in results[i].items():\n",
    "        observed_state = int(key, 2)\n",
    "        A_1[observed_state][true_state] = val / shots\n",
    "\n",
    "print(A_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "cbc4a228-935f-413c-9ad3-b6e26f22e802",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mitigated counts:\n",
      "[476   3   0   1  12  19   9 501]\n"
     ]
    }
   ],
   "source": [
    "A = reduce(np.kron, [A_1] * n_qubits)  # joint confusion matrix\n",
    "A_pinv = np.linalg.pinv(A)  # Generate pseudoinverse confusion matrix.\n",
    "mitigated = np.array(np.dot(A_pinv, noisy_res_1),\n",
    "                     dtype=int)  # Obtain mitigated counts\n",
    "print(f\"Mitigated counts:\\n{mitigated}\")\n",
    "\n",
    "if not np.all(mitigated >= 0):\n",
    "    positive_dist = find_closest_distribution(mitigated / shots)\n",
    "    mitigated = get_counts_from_distribution(n_qubits, shots, positive_dist)\n",
    "    print(f\"\\nCorrected for negative counts:\\n{mitigated}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b65c4657-87f7-44df-b205-7fc6195b95a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.DataFrame({\n",
    "    \"states\": states,\n",
    "    \"noisy\": np.around(noisy_res_1 / sum(noisy_res_1), 3),\n",
    "    \"mitigated_sg\": np.around(mitigated / sum(mitigated), 3),\n",
    "})\n",
    "\n",
    "ax = df.plot(x=\"states\",\n",
    "             y=[\"noisy\", \"mitigated_sg\"],\n",
    "             kind=\"bar\",\n",
    "             figsize=(8, 5))\n",
    "ax.bar_label(ax.containers[0], labels=df[\"noisy\"])\n",
    "ax.bar_label(ax.containers[1], labels=df[\"mitigated_sg\"])\n",
    "ax.set_ylabel(\"probabilities\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2927e72-98bb-41cf-8e77-35ea9572474a",
   "metadata": {},
   "source": [
    "## Inverse confusion matrix from k local confusion matrices\n",
    "\n",
    "This method works under the assumption that the readout errors for different qubits are independent of each other and the confusion matrix $A$ can be factorized into the product of $k$ small local confusion matrices. We consider the special case when $k = n$ for $n$ qubits and different $2 \\times 2$ confusion matrices for each qubit\n",
    "\n",
    "$$\n",
    "A = A_1 \\otimes \\dots \\otimes A_n\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1e8fd13a-e0cf-4139-84ca-d81f7a71baa6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "000 becomes {'000': 388, '010': 235, '111': 18, '001': 174, '011': 79, '100': 58, '101': 28, '110': 44}\n",
      "111 becomes {'000': 23, '010': 38, '111': 370, '001': 40, '011': 60, '100': 107, '101': 224, '110': 162}\n"
     ]
    }
   ],
   "source": [
    "local_labels = [[0] * n_qubits, [1] * n_qubits]\n",
    "local_states = [\"0\" * n_qubits, \"1\" * n_qubits]\n",
    "\n",
    "results = [\n",
    "    cudaq.sample(kernel,\n",
    "                 n_qubits,\n",
    "                 label,\n",
    "                 shots_count=shots,\n",
    "                 noise_model=noise_2) for label in local_labels\n",
    "]\n",
    "\n",
    "for i, state in enumerate(local_states):\n",
    "    res = dict(list(results[i].items()))\n",
    "    print(f\"{state} becomes {res}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f592fb8-2ded-498e-b4fe-eff6eac74750",
   "metadata": {},
   "source": [
    "The local confusion matrices are generated using the marginal probability distribution for each qubit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7fabcc1f-8d9c-42c2-b02a-3ce42c1e34c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "counts = [\n",
    "    dict(list(results[i].items())) for i, state in enumerate(local_states)\n",
    "]\n",
    "matrices = []\n",
    "\n",
    "for k in range(n_qubits):\n",
    "    matrix = np.zeros([2, 2], dtype=float)\n",
    "    marginalized_counts = []\n",
    "    total_shots = []\n",
    "    for i in range(2):\n",
    "        marginal_cts = dict(results[i].get_marginal_counts([k]).items())\n",
    "        marginalized_counts.append(marginal_cts)\n",
    "        total_shots.append(sum(marginal_cts.values()))\n",
    "\n",
    "    # matrix[i][j] is the probability of counting i for expected j\n",
    "    for i in range(2):\n",
    "        for j in range(2):\n",
    "            matrix[i][j] = marginalized_counts[j].get(str(i),\n",
    "                                                      0) / total_shots[j]\n",
    "    matrices.append(matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7f016f9b-3243-42b3-ab59-4d03f7765b82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.85546875 0.15722656]\n",
      " [0.14453125 0.84277344]]\n",
      "\n",
      "[[0.6328125  0.38476562]\n",
      " [0.3671875  0.61523438]]\n",
      "\n",
      "[[0.70800781 0.32226562]\n",
      " [0.29199219 0.67773438]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for m in matrices:\n",
    "    print(m)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "51734299-307f-4081-b8cc-1968ebfc7d52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mitigated counts:\n",
      "[559  -1 -58  32 -28  26 -16 510]\n",
      "\n",
      "Corrected for negative counts:\n",
      "[521   0   0  35   0  22   0 446]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# To find the joint pseudoinverse confusion matrix, we can first perform pseudoinverse of the\n",
    "# local confusion matrices and then do the tensor product\n",
    "\n",
    "pinv_confusion_matrices = [np.linalg.pinv(m) for m in matrices]\n",
    "A_pinv = reduce(np.kron, pinv_confusion_matrices)\n",
    "\n",
    "mitigated = np.array(np.dot(A_pinv, noisy_res_2), dtype=int)\n",
    "print(f\"Mitigated counts:\\n{mitigated}\")\n",
    "\n",
    "if not np.all(mitigated >= 0):\n",
    "    positive_dist = find_closest_distribution(mitigated / shots)\n",
    "    mitigated = get_counts_from_distribution(n_qubits, shots, positive_dist)\n",
    "    print(f\"\\nCorrected for negative counts:\\n{mitigated}\")\n",
    "\n",
    "A_joint = reduce(np.kron, matrices)\n",
    "plot_cmat(A_joint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "4261d8a3-b701-4939-8219-c0d823d42747",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.DataFrame({\n",
    "    \"states\": states,\n",
    "    \"noisy\": np.around(noisy_res_2 / sum(noisy_res_2), 3),\n",
    "    \"mitigated_k_local\": np.around(mitigated / sum(mitigated), 3),\n",
    "})\n",
    "\n",
    "ax = df.plot(x=\"states\",\n",
    "             y=[\"noisy\", \"mitigated_k_local\"],\n",
    "             kind=\"bar\",\n",
    "             figsize=(8, 5))\n",
    "ax.bar_label(ax.containers[0], labels=df[\"noisy\"])\n",
    "ax.bar_label(ax.containers[1], labels=df[\"mitigated_k_local\"])\n",
    "ax.set_ylabel(\"probabilities\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9329a30d-9224-42b1-9a66-1e87ba7c2674",
   "metadata": {},
   "source": [
    "## Inverse of full confusion matrix\n",
    "\n",
    "Here we generate a quantum circuit for each of the basis states of $n$ qubits (i.e., $2^n$ combinations). This gives more accurate readout error mitigation. Since it scales exponentially with the number of qubits, it is only practical for small devices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "cf6025e8-1755-4c8f-96fa-1b67830d448d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "000 becomes {'000': 367, '010': 248, '111': 17, '001': 159, '011': 83, '100': 68, '101': 35, '110': 47}\n",
      "001 becomes {'000': 161, '010': 93, '111': 46, '001': 363, '011': 253, '100': 17, '101': 76, '110': 15}\n",
      "010 becomes {'000': 234, '010': 378, '111': 27, '001': 100, '011': 150, '100': 36, '101': 25, '110': 74}\n",
      "011 becomes {'000': 106, '010': 145, '111': 65, '001': 251, '011': 386, '100': 11, '101': 30, '110': 30}\n",
      "100 becomes {'000': 83, '010': 34, '111': 99, '001': 29, '011': 18, '100': 388, '101': 144, '110': 229}\n",
      "101 becomes {'000': 22, '010': 13, '111': 247, '001': 70, '011': 43, '100': 163, '101': 371, '110': 95}\n",
      "110 becomes {'000': 32, '010': 77, '111': 157, '001': 14, '011': 30, '100': 233, '101': 85, '110': 396}\n",
      "111 becomes {'000': 14, '010': 31, '111': 393, '001': 38, '011': 60, '100': 95, '101': 233, '110': 160}\n"
     ]
    }
   ],
   "source": [
    "results = [\n",
    "    cudaq.sample(kernel,\n",
    "                 n_qubits,\n",
    "                 label,\n",
    "                 shots_count=shots,\n",
    "                 noise_model=noise_2) for label in labels\n",
    "]\n",
    "\n",
    "for i, state in enumerate(states):\n",
    "    res = dict(list(results[i].items()))\n",
    "    print(f\"{state} becomes {res}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "28f2b2cb-13d3-4806-852d-06ea91e58c1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate full confusion matrix\n",
    "A_full = np.zeros((2**n_qubits, 2**n_qubits))\n",
    "for i, state in enumerate(states):\n",
    "    true_state = int(state, 2)\n",
    "    for key, val in results[i].items():\n",
    "        observed_state = int(key, 2)\n",
    "        A_full[observed_state][true_state] = val / shots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c3b0b80b-63ac-438a-9f3d-a6a3687da167",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_cmat(A_full)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "507852a8-6715-4802-b6a0-10967d09ed94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.09734490298929"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Distance between full confusion matrix and tensored confusion matrix\n",
    "np.linalg.norm(A_joint - A_full)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9e6c3874-2905-4c25-9bf0-22ab27756fed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mitigated counts:\n",
      "[ 714 -100 -211  152  -49   63   32  422]\n",
      "\n",
      "Corrected for negative counts:\n",
      "[683   0   0  39   0   0   0 302]\n"
     ]
    }
   ],
   "source": [
    "A_pinv = np.linalg.pinv(A_full)\n",
    "mitigated = np.array(np.dot(A_pinv, noisy_res_2), dtype=int)\n",
    "print(f\"Mitigated counts:\\n{mitigated}\")\n",
    "\n",
    "if not np.all(mitigated >= 0):\n",
    "    positive_dist = find_closest_distribution(mitigated / shots)\n",
    "    mitigated = get_counts_from_distribution(n_qubits, shots, positive_dist)\n",
    "    print(f\"\\nCorrected for negative counts:\\n{mitigated}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "cb109820-5478-4179-84b8-66e6af1008fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+kAAAHSCAYAAACQH4o4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB9xElEQVR4nOzdeVxU1f/H8ffMAG4ouytuiAqCa5bfSM3Ulq9Lmqb5TU39mpammXtoueRaaeaWS5KauYRRlqZWaptlueaWO7lvwOAKCszM7w9/Tc1XNIWBGeH1fDx4yJx77rmfM5cBP/eee47BZrPZBAAAAAAAXM7o6gAAAAAAAMANJOkAAAAAALgJknQAAAAAANwESToAAAAAAG6CJB0AAAAAADdBkg4AAAAAgJsgSQcAAAAAwE2QpAMAAAAA4CZI0gEAAAAAcBMk6QAAAAAAuAm3SNIXL16sxo0bq3r16mrXrp127dp1y7qdO3dW1apVb/rq2bNnLkYMAAAAAIDzebg6gNWrV2vChAkaPXq0atasqYULF6p79+5au3atAgICbqo/ffp0paen219fuHBBrVq10hNPPJGbYQMAAAAA4HQuv5M+f/58tW/fXm3btlVoaKhGjx6tggULKi4uLtP6vr6+CgoKsn/99NNPKliwIEk6AAAAAOCe59IkPS0tTXv37lVUVJS9zGg0KioqSjt27LijNuLi4tS8eXMVLlw4p8IEAAAAACBXuDRJT05OlsViuWlYe0BAgBITE/9x/127dungwYNq165dToUIAAAAAECucfkz6dnxySefqEqVKqpRo8Zd75uUdFk2Ww4EBQAAAADA3xgMUkBA0Tuq69Ik3c/PTyaTSUlJSQ7lSUlJCgwMvO2+KSkp+vLLL/Xyyy9n6dg2m0jSAQAAAABuxaXD3b28vBQREaFNmzbZy6xWqzZt2qTatWvfdt+1a9cqLS1NTz75ZE6HCQAAAABArnD5cPdu3bpp6NChioyMVI0aNbRw4UKlpqaqTZs2kqQhQ4aoRIkSGjhwoMN+n3zyiZo2bSo/Pz9XhA0AAAAAgNO5PElv1qyZzGazpk2bpoSEBIWHh2vevHn24e5nzpyR0eh4wz8+Pl7btm3TBx984IqQAQAAAADIEQabLX8+mZ2YmL8mjouLi9XSpYtkNiepUqXK6t9/sKpVi7xl/cuXL2vu3Pf0ww8bdOnSJZUoUUr9+g3Qgw/Wt9dJSDivWbOm65dffta1a9cUHBysYcNGKiysmiSpfv26mbbdu/fLevbZ55zbQQAAAORpNptNGRnprg4DuCUPD08ZDIZMtxkMUmDgnU0cR5KeD6xf/7XGjh2pQYOiVa1apGJjl+rbb9dp6dI4+fn531Q/PT1dvXp1l5+fnzp37qagoOI6e/aMvL2LqnLlKpKkS5cu6b//7ag6deqqdeu28vX108mTJ1SmTLDKlAmWJCUlOS6j98svP2vixDFatuwzex0AAADgn2RkpCsp6axsNqurQwFuyWAwKiCgpDw8PDPZdudJusuHuyPnLVu2WC1btlbz5jcm2Rs8OFqbNm3UqlVfqHPnrjfV//LLz3Xp0kXNnv2BPDxu/IiUKlXaoc7ixQtVvHgJDRs20l5WunQZhzoBAY4z9G/c+L3q1KlLgg4AAIA7ZrPZdPGiWUajUT4+QTIYXDr3NZApm82qCxeSdPGiWf7+xW95R/1OkKTncenp6Tp4cL86d+5mLzMajapb9wHt3bsr0302bvxBkZE1NHnym9q48Xv5+vrq0UefUMeOXWQymSRJP/30gx544F967bWh+u237QoKCtJTT7XTk08+lWmbZnOSfv55o4YPH+38TgIAACDPslotSk+/Jh+fQHl5FXR1OMAtFS3qq4sXE2W1WmQyZT3V5jJUHnfx4gVZLBb5+zsOa/f3979pffo/nT59St99t15Wq0Vvvz1VXbs+r2XLFmvhwhiHOitWxKls2XJ6553pat36ab377iStWbMq0zbXrFmlwoWL6OGHH3Fe5wAAAJDnWa03hrhnJ+kBcsOfP6N//sxmFT/puInVapOvr5+GDBkuk8mksLBwJSSc19Kli/Tf//b8/zpWhYVV0wsvvCRJqlIlTH/8cUQrVsTp3/9ucVObX375hR577AkVKFAgV/sCAACAvCE7w4eB3OCsn1HupOdxPj6+MplMMpvNDuVms1kBAQGZ7hMYGKiyZcvbh7ZLUvnyFZWUlKT09BszagYEBKpChYoO+5UvX1Hnzp29qb2dO3fo+PFjatGidTZ7AwAAAAB5G0l6Hufp6akqVcK0bdtme5nVatW2bVsUEVEj032qV6+pU6dOOAzTOHHiuAICAuXp6Wmvc/z4MYf9Tpw4ppIlS93U3qpVn6tq1XD7zPAAAABAdhmNBnl4GHPty2jM3Tv5MTFz1LXrs7l6TLgHhrvnAx06dNS4caMUFlZN4eERio1dotTUVDVv3lKSNGbMCAUFFdeLL/aRJLVu3VZxcbGaOnWS2rZ9RidPntCiRfP19NPP2Nt85pln9eKL/9WHH36gxo0f1e+/79UXX3ymIUOGOxz76tUr+vbbderT55Vc6y8AAADyNqPRIB/fwvIw5d49xwyLVRcvpMhqzZ11nP/zn84O//9G/kGSng80afKYLlxI1rx5s2U2Jyk0tIomT54uf/8bw93PnTsro/GvX3AlSpTUO+9M17Rp76hr1/8oMDBI7dp1UMeOXex1wsMjNH78JM2ZM0MLFsxTqVKl9fLLA/XYY/92OPa6dV/LZrOpadMncqezAAAAyPOMRoM8TEb1W7ZDh89fyfHjhRb31tQOtWU0GnItSS9cuLCkwrlyLLgXg81my52fMjeTmHhZ+bPnAAAAwL0jPT1NSUlnFBBQSp6eXpIkDw+j/PyKqPm0H7X39KUcjyGidDF9+XIDJSdfVUbGnc3c3adPT4WGVpaXl5dWrvxcnp6eatWqjbp3f0GSdPbsWb377lvatm2LDAaj6tV7UP37D7bfSIuJmaMff/xeCxYskSRt375Vs2ZN0x9/xMvDw0MVK4Zo5Mhxstlsat++ld5/f6HCwqrZjx8bu0Qff7xEy5d/4XBDDjkns5/VPxkMUmBg0Ttqh7MFpz7Pk9vP6gAAAADuas2aVSpYsJDmzl2gXr36asGCedqy5RdZrVZFRw/QpUuXNH36XE2ZMlOnT5/SiBHRmbaTkZGhYcMGqVat+7Rw4TLNnj1fTz7ZRpJBpUqVVt26D+jLL1c67PPllyvVrFlLEvR7EMPd8zmj0SBfv0IyGU3/XPkOWKwWXUhOzbVhQAAAAIC7qlSpsn0J47Jly+nTT2O1desWSVJ8/BHFxn6uEiVKSpJee220Ondur3379io8PMKhnZSUq7py5YqiouqrTJlgSXJYaalFi9aaNGmC+vbtLy8vLx04sF/x8Yc1ceLk3OgmnIwkPZ8zGg0yGU169YdXFX8xPltthfiEaGLDibn6rA4AAADgripVquzwOiAgUMnJZh09elTFi5ewJ+iSVLFiiLy9i+ro0T9uStKLFfNRs2YtNXBgX9WtW0916z6gxo0fVWBgoCSpYcNGmjLlTf3ww7dq2vRxrVmzUnXq1FWpUqVzvpNwOpJ0SJLiL8Zrn3mfq8MAAAAA8gwPD8d0y2AwKKtTgg0bNlJPP/2Mfv11kzZs+Ebvvz9LU6bMVGRkdXl6eurxx5tr9eqVevjhxvrmm7Xq12+QM7oAF+ABBQAAAADIRRUqVND58+d07txZe9kff8TrypXLqlgx5Jb7VakSps6du2n27A8UElJJ69attW9r2bK1tm7drM8+Wy6LxaKHH34kR/uAnEOSDgAAAAC5qG7degoJqaQ33nhdBw7s1++/79HYsSNVq1Ydhxna/3T69CnNnj1De/bs0tmzZ7R58y86efK4ypf/67n0ChUqKiIiUrNmTVfTpo+rQIGCudklOBHD3QEAAADck0KLe9+TxzEYDJow4R29++5b6tOnh8MSbJkpWLCgjh07qjVrVunSpYsKCAhUmzbt1apVG4d6zZu30u7du9S8+ZNOjRe5i3XS87k/15hsv7J9tp9JD/cPV2zL2LtaPxIAAAC4nczWnjYaDfLxLSwPU+4NDM6wWHXxQopbT5C8YME8ffvtOi1cuMzVoeRLzlonnTvpAAAAAO4pVqtNFy+kyGg05Oox3TVBT0lJ0dmzpxUXF6sePXq5OhxkE0k6AAAAgHuOOyfNuW3KlLe0bt1XatCgEUPd8wCSdAAAAAC4hw0fPkrDh49ydRhwEmZ3BwAAAADATZCkAwAAAADgJkjSAQAAAABwEyTpAAAAAAC4CZJ0AAAAAADcBEk6AAAAAABugiQdAAAAwD3HaDTIw8OYa19GoyFH+7N9+1bVr19Xly9fvm29p59uqdjYJTkaS3bExMxR167P3lHdceNGKTp6YI4fx1ly671nnXQAAAAA9xSj0SB/34IymHIvnbFZMmS+cE1Wqy1H2q9evaY+/3ytvL29JUmrV6/UtGmTtXbtdw713n//QxUqVMipx46JmaMff/xeCxa4b/Kfn5CkAwAAALinGI2GGwl63PNS4sGcP2BgFRnazpPRaMixJN3T01MBAYH/WM/Pzy9Hjg/3QZIOAAAA4N6UeFA6s9PVUWSqT5+eqlQpVEajSWvWrJKnp6d69OilRx99QlOmvKVvv10vf39/vfLKYD344EPavn2rXn75Ra1Z860OHTqg8eNHS5Lq168rSerWrYe6d39BTz/dUu3b/0ft298Y6n3s2FFNnDhGBw7sU+nSZdSv3yD17/+Sxo+fpIYNG0mS3ntvmn744TslJJyTv3+gHnvsCXXr1kMeHh5avXql5s9/3+FYw4aNVLNmLXX58mXNnPmuNm78Xmlp6QoLC1ffvgNUuXIVez8XLVqg2Nglunbtmho3bipf36xfRNi3b68GD+6nDh06qVOnrne1r9Vq1cKFMfrii8904UKyypevqBdf7KN//SvKXuf8+XOaOXOqNm/+RenpaSpfvqIGDBiqiIhInTp1UtOnv6O9e/fo2rVUlS9fUS+88JLuv79elvuTVSTpAAAAAJAD1qz5Us8+21nvv79Q69d/rcmTJ+qHH75Vw4aPqHPnbvr44yUaO3aE4uK+dNivevWaevnlgYqJma0lS+IkSYUKFb6pfYvFoujogSpRoqTmzFmglJQUzZgx5aZ6hQsX1vDhIxUYGKQjRw7rrbfGqXDhwurYsYuaNHlU8fFH9OuvP+vdd9+TJPuQ+9dfH6oCBQpo0qRpKlLEW59//qleeaWXli79VMWK+Wj9+m80f/5cDRgwRDVq1NLatav1yScfq3TpMnf9Xm3btkXDhw9Wr14vq1WrNne9//LlS7Vs2UcaPHiYqlSpqlWrvtCrrw7QokWxKlu2nFJSUtSnT08FBRXXxInvKCAgQAcO7JfNZpUkpaSk6F//ekg9e/aWp6eX1q79UkOHDtCSJXEqWbLkXceTHSTpAAAAAJADQkMrq2vX5yVJnTt30+LFC+Xj46snn3xKktSt2/NaseITHT58yGE/T09PeXt7y2Aw3HYI/JYtv/7/HeA59no9e/ZW//4vOdT7MwZJKlWqtI4fP6b1679Wx45dVKBAQRUqVEgmk4fDsXbu/E379u3VypXfyMvLS5LUp88r+vHH7/Ttt+vVqlUbLV++VM2bt1KLFq3tx966dbPS0tLu6n36/vtvNXbsSL366mtq0uSxu9r3T0uXfqSOHbuoadPHJUm9e7+sHTu2KjZ2qQYOHKpvvlmrCxcuaN68D1WsmI8kKTi4rH3/ypWrOIwQ6NGjl3744Vv99NP3atv2mSzFlFUk6QAAAACQAypVqmz/3mQyqVgxH1WqFGov8/cPkCRduGBW4cJF7rr948ePqXjxkg7JdbVqETfVW7/+a33yyTKdOnVKqakpslgs/3i8w4cPKjU1Vc2bN3Eov379uk6dOilJOnr0j5vuekdGVtf27dvuuA+//75HP/+8UWPGvGkfnn+3rl69osTEBFWvXtOhvHr1mvYLIIcOHVSVKlXtCfr/SklJ0QcfzNWmTRuVlJQoi8Wi69ev69y5s1mKKTtI0gEAAAAgB3h4OKZbBoPBocxguLGsW05NRidJe/bs0htvvK7//ren6tV7UEWKeGv9+q+1bNlHt90vNTVFAQGBmj59zk3bvL2LOi2+0qWDVayYj7788nNFRdW/6T1zlgIFCtx2+8yZ72rLll/10kuvKDi4rAoUKKDXXhuq9PSMHInndlgnHQAAAADcjIeHpywW623rlCtXXufPn5XZnGQv27fvd4c6u3fvUokSJdWlS3eFhVVT2bLldPbsGYc6np6eslotDmVVq4bJbE6SyWRScHBZhy9fX19JUoUKFfX773sd9tu7d89d9dPX11fTps3WqVMn9frrryoj4+6T4iJFvBUYGKTdux0nEdy9e6cqVKgo6cajB4cOHdClSxczbWP37p1q1qylHn74EVWqFCp//wCdPXv6rmNxBpJ0AAAAAHAzpUqVUmpqirZu3awLFy7o2rVrN9W5//56KlMmWGPHjtLhw4e0a9dvev/9WZKk/79Jr7Jly+rcubNat+4rnTp1UsuXL9MPP3zn0E7JkqV15sxpHTp0QBcuXFBaWprq1q2niIjqio4epM2bf9GZM6e1e/dOzZkzU/v337gQ0K5dB3355Rf68ssvdPz4McXEzNEff8TfdV/9/Pw1deosHT9+VKNGDctSov7ss521ePGNCfqOHz+qWbOm69Chg2rX7j+SpKZNH5e/f4Ciowdp167fdOrUSX333Xrt2bNLkhQcXE7ff79Bhw4d0KFDBzV69PAcHeFwOwx3BwAAAHBvCqzyz3XupeP8TfXqNdW6dVuNHBmtixcv2pdg+zuTyaQJEyZr4sQx6tHjOZUuXUa9e/fT0KH95eV1Y3h3/foP65lnntWUKW8pLS1dUVEPqWvX7vrgg7n2dho1aqwfftigvn1f1JUrl+1LsE2aNFVz576n8eNH68KFZPn7B6hWrTry8/OXJDVp8phOnTqpWbOm6fr1NDVq1FitW7fV5s2/3HV/AwICNXXqbPXt21NvvPG6Ro4cK5PJdMf7P/10B125ckUzZryr5GSzKlQI0cSJ76hs2XKSbowWmDJlpmbMmKLBg/vJYrGoQoUQDRgwRJLUt29/TZjwhl588b/y8fFVx45ddPXq1bvuhzMYbDabay4PuFhi4mXlz5478vAwys+viNqvbK995n3ZaivcP1yxLWOVnHxVGRm3H5oDAAAA3In09DQlJZ1RQEApeXremGXcaDTI37egDKbcu+dos2TIfOGay+6u3qldu35T797P6+OPV6hMmWBXh5OvZPaz+ieDQQoMvLNn+bmTDgAAAOCeYrXaZL5wTUajIVeP6Y4J+vfff6vChQspOLicTp48oalTJ6t69Zok6PcwknQAAAAA9xx3TZpzW0rKVc2aNV3nz5+Vj4+v6tZ9QH36vOLqsCRJjz7a4JbbJk2appo1a99ye6dO7XXu3JlMtw0ePEyPPfbvbMfnrkjSAQAAAOAe9e9/t9C//93C1WFkav78JbfcFhQUdNt9J02aessJ5Pz9/bMVl7sjSQcAAAAAOF1wcNks71uyZCknRnJvYQk2AAAAAADchMuT9MWLF6tx48aqXr262rVrp127dt22/qVLlzR69GjVr19fkZGRevzxx/X999/nUrQAAAAAAOQclw53X716tSZMmKDRo0erZs2aWrhwobp37661a9cqICDgpvppaWnq1q2bAgICNHXqVJUoUUKnT59WsWLFXBA9AAAAAADO5dIkff78+Wrfvr3atm0rSRo9erS+++47xcXFqWfPnjfVj4uL08WLF7Vs2TJ5enpKkoKDWVoAAAAAAJA3uGy4e1pamvbu3auoqKi/gjEaFRUVpR07dmS6z4YNG1SrVi298cYbioqKUosWLTR79mxZLJbcChsAAAAAgBzjsiQ9OTlZFovlpmHtAQEBSkxMzHSfEydO6KuvvpLFYtHcuXPVu3dvzZ8/X7NmzcqNkAEAAAC4CaPRIA8PY659GY2GHO3P9u1bVb9+XV2+fPm29Z5+uqViY2+9tJmrxcTMUdeuz95V/ZYtH1P9+nX1ww/f3dE+//se3M2+94J7agk2m82mgIAAjRkzRiaTSZGRkTp37pxiYmLUp08fV4cHAAAAIBcYjQb5+hWSyWjKtWNarBZdSE6V1WrLkfarV6+pzz9fK29vb0nS6tUrNW3aZK1d+51Dvfff/1CFChVy6rFjYuboxx+/14IFuZv8Hz36h+bPf1/jx09SRESkihZlrjHJhUm6n5+fTCaTkpKSHMqTkpIUGBiY6T5BQUHy8PCQyfTXhzEkJEQJCQlKS0uTl5dXjsYMAAAAwPWMRoNMRpNe/eFVxV+Mz/HjhfiEaGLDiTIaDTmWpHt6eiogIPM86O/8/Pxy5PiucOrUSUlSgwYPy2DI2ZEK9xKXJeleXl6KiIjQpk2b1LRpU0mS1WrVpk2b1KlTp0z3qVOnjlatWiWr1Sqj8cZI/aNHjyooKIgEHQAAAMhn4i/Ga595n6vDyFSfPj1VqVKojEaT1qxZJU9PT/Xo0UuPPvqEpkx5S99+u17+/v565ZXBevDBh7R9+1a9/PKLWrPmWx06dEDjx4+WdGMotyR169ZD3bu/oKefbqn27f+j9u1vDCk/duyoJk4cowMH9ql06TLq12+Q+vd/SePHT1LDho0kSe+9N00//PCdEhLOyd8/UI899oS6deshDw8PrV69UvPnv+9wrGHDRqpZs5a6fPmyZs58Vxs3fq+0tHSFhYWrb98Bqly5ir2fixYtUGzsEl27dk2NGzeVr++dXUSIiZljP26DBvdLkjZu3Ko+fXqqcuWq6tdvoL1udPRAeXsX1fDho7J4Nu4tLh3u3q1bNw0dOlSRkZGqUaOGFi5cqNTUVLVp00aSNGTIEJUoUUIDB944Qf/5z3/00Ucfady4cerUqZOOHTumOXPmqHPnzq7sBgAAAADcZM2aL/Xss531/vsLtX7915o8eaJ++OFbNWz4iDp37qaPP16isWNHKC7uS4f9qlevqZdfHqiYmNlasiROklSoUOGb2rdYLIqOHqgSJUpqzpwFSklJ0YwZU26qV7hwYQ0fPlKBgUE6cuSw3nprnAoXLqyOHbuoSZNHFR9/RL/++rPeffc9SbIPuX/99aEqUKCAJk2apiJFvPX555/qlVd6aenST1WsmI/Wr/9G8+fP1YABQ1SjRi2tXbtan3zysUqXLvOP781//tNZpUqV1vjxo/X552vv+r3Ny1yapDdr1kxms1nTpk1TQkKCwsPDNW/ePPtw9zNnztjvmEtSqVKlFBMTowkTJujJJ59UiRIl9Nxzz6lHjx6u6gIAAAAAZCo0tLK6dn1ektS5czctXrxQPj6+evLJpyRJ3bo9rxUrPtHhw4cc9vP09JS3t7cMBsNth8Bv2fKrTp06qenT59jr9ezZW/37v+RQ788YJKlUqdI6fvyY1q//Wh07dlGBAgVVqFAhmUweDsfaufM37du3VytXfmMftdynzyv68cfv9O2369WqVRstX75UzZu3UosWre3H3rp1s9LS0v7xvSlcuLC8vYtK0h0N889PXD5xXKdOnW45vH3RokU3ldWuXVuxsbE5HRYAAAAAZEulSpXt35tMJhUr5qNKlULtZf7+N1a6unDBrMKFi9x1+8ePH1Px4iUdktxq1SJuqrd+/df65JNlOnXqlFJTU2SxWP7xeIcPH1RqaqqaN2/iUH79+nX7s+RHj/6hVq3aOGyPjKyu7du33XVf8BeXJ+kAAAAAkBd5eDimWwaDwaHsz8nScmoyOknas2eX3njjdf33vz1Vr96DKlLEW+vXf61lyz667X6pqSkKCAjU9Olzbtr25x3wnGA0GmWzOb4fGRkZOXY8d0SSDgAAAABuxsPDUxaL9bZ1ypUrr/Pnz8psTrLfld+373eHOrt371KJEiXVpUt3e9nZs2cc6nh6espqtTiUVa0aJrM5SSaTSaVKlc70+BUqVNTvv+/Vv//dwl62d++ef+7cbfj6+ikpKdH+2mKxKD7+iOrUqZutdu8lxn+uAgAAAADITaVKlVJqaoq2bt2sCxcu6Nq1azfVuf/+eipTJlhjx47S4cOHtGvXb3r//VmSpD9XNCtbtqzOnTurdeu+0qlTJ7V8+TL98MN3Du2ULFlaZ86c1qFDB3ThwgWlpaWpbt16ioiorujoQdq8+RedOXNau3fv1Jw5M7V//40LAe3addCXX36hL7/8QsePH1NMzBz98Uf2lsSrU6euNm3aqJ9/3qhjx45q0qSJunLlcrbavNdwJx0AAADAPSnEJyRPHefvqlevqdat22rkyGhdvHjRvgTb35lMJk2YMFkTJ45Rjx7PqXTpMurdu5+GDu0vL68CkqT69R/WM888qylT3lJaWrqioh5S167d9cEHc+3tNGrUWD/8sEF9+76oK1cu25dgmzRpqubOfU/jx4/WhQvJ8vcPUK1adeTn5y9JatLkMZ06dVKzZk3T9etpatSosVq3bqvNm3/Jcr9btGilw4cPaezYkTKZTGrf/tl8dRddkgy2/x3wn08kJl5W/uy5Iw8Po/z8iqj9yvbZXmMy3D9csS1jlZx8VRkZtx+aAwAAANyJ9PQ0JSWdUUBAKXl63phl3Gg0yNevkExGU67FYbFadCE5NUefH3eGXbt+U+/ez+vjj1eoTJlgV4eTr2T2s/ong0EKDLyzZ/m5kw4AAADgnmK12nQhOVVGoyFXj+mOCfr333+rwoULKTi4nE6ePKGpUyerevWaJOj3MJJ0AAAAAPccd02ac1tKylXNmjVd58+flY+Pr+rWfUB9+rzi6rAkSY8+2uCW2yZNmqaaNWvnYjT3DpJ0AAAAALhH/fvfLRxmV3cn8+cvueW2oKCgXIzk3kKSDgAAAABwuuDgsq4O4Z7EEmwAAAAAALgJknQAAAAAbi+fLkqFe4izfkYZ7g4AAADAbZlMHpIMunLlory9fWQw5N6M7sCdstlsunLloiTD///MZh1JOgAAAAC3ZTQa5ecXpOTkBJnNqa4OB7gNg/z8gmQ0Zm/AOkk6AAAAALdWoEAhFS8eLIslw9WhALdkMnlkO0GXSNIBAAAA3AOMRqOMRi9XhwHkOCaOAwAAAADATZCkAwAAAADgJkjSAQAAAABwEyTpAAAAAAC4CZJ0AAAAAADcBEk6AAAAAABugiQdAAAAAAA3QZIOAAAAAICbIEkHAAAAAMBNkKQDAAAAAOAmSNIBAAAAAHATJOkAAAAAALgJknQAAAAAANwESToAAAAAAG6CJB0AAAAAADfh4eoAcGtxcbFaunSRzOYkVapUWf37D1a1apGZ1l29eqXGjx/tUObl5aUNG362v7bZbIqJmaOVKz/T5ctXVL16TQ0dOkx+fuH2OtazVlk2WGQ7Y5OMkrGqUaamJhm8DDnTSQAAAACAHUm6m1q//mvNmDFFgwZFq1q1SMXGLtWAAX21dGmc/Pz8M92nSJEiWrIkzv7aYHBMrBcvXqhPPlmm4cNHqVSpMpo3b5ZeeeUlrV27RpJku2xTxpIMGcON8njcQ7brNlnWWZSxMkOebT1zrrMAAAAAAEkMd3dby5YtVsuWrdW8+ZOqWDFEgwdHq2DBglq16otb7mMwGBQQEGj/8vcPsG+z2Wxavnypnnuuuxo0aKTQ0Mp67bU3lJiYoHXr1kmSrIetklEyPWGSIcAgY2mjTE+YZDtgk81sy/E+AwAAAEB+R5LuhtLT03Xw4H7VrVvPXmY0GlW37gPau3fXLfdLTU1V27Yt1KZNc7366gDFxx+xbzt9+pSSkpJ0//0P2Mu8vb0VERGpHTt23CjIkGRyvANv8LjxvfWk1Um9AwAAAADcCkm6G7p48YIsFov8/R2Htfv7+yspKSnTfcqVK69XX31dEydO1uuvvyGr1aZevf6r8+fPSZLM5hv7+fkFOOzn7x+gxMRESZKhgkG6Kll+schmscmWalPGtxk3Kl5xZg8BAAAAAJnhmfQ8IjKyhiIja9hfV69eUx07Pq3PP/9UPXr0uqM2jEFGmVqaZFlnkeVby42J4+oaZStik5g3DgAAAAByHEm6G/Lx8ZXJZJLZbHYoN5vNCggIuMVejjw8PFS5clWdPHlCkuzPpycnJykwMPBvbSYpMjJCp3VakmSKMMkUYZLtik3yulHHutkqgy9ZOgAAAADkNIa7uyFPT09VqRKmbds228usVqu2bduiiIgat9nzLxaLRfHxh+0JeenSZRQQEKCtW7fY61y9ekV79+5R7dq1b9rf4G2Qwcsg6z6r5CEZKpKkAwAAAEBO4066m+rQoaPGjRulsLBqCg+PUGzsEqWmpqp585aSpDFjRigoqLhefLGPJGn+/PcVEVFdZcoE68qVK1qy5EOdPXtWLVq0lnRjMrh27f6jhQtjVLZsWfsSbIGBQWratKkWfr1QkmTZapEh2CCDp0HWP26smW56xCRDQZJ0AAAAAMhpJOluqkmTx3ThQrLmzZstszlJoaFVNHnydPuw9XPnzspo/GsgxOXLl/Tmm2NlNiepaNFiqlo1TLNnx6hixRB7nY4du+jatWt6663xunLlsqpXr6V3352hAgUK2OvYTttk+dEipUmGAINM/zbJVN2Uex0HAAAAgHzMYLPZ8uUC2ImJl5U/e+7Iw8MoP78iar+yvfaZ92WrrXD/cMW2jFVy8lVlZLBkGwAAAABIksEgBQYWvaO6PJMOAAAAAICbYLj7PcpoNMhozP5z4iYT12kAAAAAwF2QpN+DjEaD/H0LymDi9AEAAABAXuIWWd7ixYsVExOjhIQEhYWF6fXXX1eNGpkvNfbpp58qOjraoczLy0u7d+/OjVDdgtFouJGgxz0vJR7MXmOhTaUmI5wTGAAAAAAgW1yepK9evVoTJkzQ6NGjVbNmTS1cuFDdu3fX2rVrFRAQkOk+3t7eWrt2rf21wZBPlwdLPCid2Zm9NgKrOCcWAAAAAEC2ufyB5Pnz56t9+/Zq27atQkNDNXr0aBUsWFBxcXG33MdgMCgoKMj+FRgYmIsRAwAAAACQM1yapKelpWnv3r2KioqylxmNRkVFRWnHjh233C8lJUWPPPKIHn74YfXq1UuHDh3KjXABAAAAAMhRLk3Sk5OTZbFYbhrWHhAQoMTExEz3qVixosaPH6/33ntPb7/9tmw2mzp06KCzZ8/mRsgAAAAAAOQYlz+Tfrdq166t2rVrO7xu1qyZli1bpldeecV1gQEAAAAAkE0uvZPu5+cnk8mkpKQkh/KkpKQ7fs7c09NT4eHhOn78eE6ECAAAAABArnFpku7l5aWIiAht2rTJXma1WrVp0yaHu+W3Y7FYdPDgQQUFBeVUmAAAAAAA5AqXD3fv1q2bhg4dqsjISNWoUUMLFy5Uamqq2rRpI0kaMmSISpQooYEDB0qSZsyYoVq1aql8+fK6dOmSYmJidPr0abVr186V3QAAAAAAINtcnqQ3a9ZMZrNZ06ZNU0JCgsLDwzVv3jz7cPczZ87IaPzrhv+lS5f0+uuvKyEhQT4+PoqIiNCyZcsUGhrqqi4AAAAAAOAUBpvNZnN1EK6QmHhZ92rPPTyM8vMrIs1pKJ3Zmb3GqreT2s5T+5Xttc+8L1tNhfuHK7ZlrJKTryojw5q9uAAAAAAgjzAYpMDAondU16XPpAMAAAAAgL+QpAMAAAAA4CZI0gEAAAAAcBMk6QAAAAAAuAmSdAAAAAAA3ARJOgAAAAAAboIkHQAAAAAAN0GSDgAAAACAmyBJBwAAAADATZCkAwAAAADgJkjSAQAAAABwEyTpAAAAAAC4CZJ0AAAAAADcBEk6AAAAAABugiQdAAAAAAA3QZIOAAAAAICbIEkHAAAAAGRJXFysnn66pRo3jlKPHl30++977mi/deu+Uv36dRUdPdChPCZmjp59tq2aNq2vJ554RP369dbevTe3+fPPG9WjRxc1bvyQnnjikZvauZd5uDoAAAAAAMC9Z/36rzVjxhQNGhStatUiFRu7VAMG9NXSpXHy8/O/5X5nzpzWzJlTVbNm7Zu2lS1bXv37D1Hp0mV0/fp1xcYu0YABL2nZshXy8/OTJH333Xq9+eY4vfBCb9Wpc78sFovi44/kWD9zG3fSAQAAAAB3bdmyxWrZsrWaN39SFSuGaPDgaBUsWFCrVn1xy30sFoveeOM1de/eU6VLl7lp+2OPPaH776+nMmWCFRJSSX379tfVq1d15MghSVJGRoamTp2sl156Wa1bP61y5cqrYsUQNWnyaI71M7eRpAMAAAAA7kp6eroOHtyvunXr2cuMRqPq1n1Ae/fuuuV+CxbMk6+vv1q0aH1Hx/j888/k7e2t0NAqkqSDB/crIeG8DAajunV7Vq1aPa6BA19WfPzhbPfJXZCkAwAAAADuysWLF2SxWOTv7zis3d/fX0lJSZnus3Pnb1q16nMNHfrabdv+6acf9eijDdS4cZRiY5doypSZ8vX1lSSdPn1KkvTBB3PVpUt3vfnmuypatKj69n1Bly5dzH7H3ABJOgAAAAAgR6WkXNXYsSM0ZMhwe8J9K3Xq1NX8+Us0a9YHqlfvQY0YEa3kZLMkyWq1SZKee+6/atSoicLCwjVs2EgZDAZt2LAup7uRK5g4DgAAAABwV3x8fGUymWQ2mx3KzWazAgICbqp/6tRJnTlzWq++OsBeZrVaJUkPP1xPS5bEqUyZYElSoUKFFBxcVsHBZRUZWV0dOjylVas+V+fO3RQYGChJqlAhxN6Ol5eXSpUqo3Pnzjq9n65Akg4AAAAAuCuenp6qUiVM27ZtVsOGjSTdSLq3bduiNm3a31S/XLkK+vDDZQ5l778/SykpKerXb6CKFy9xy2NZrValpaVJkqpWDZOXl5dOnDiqmjVrSboxmdzZs2dUsmQp53TOxUjSAQAAAAB3rUOHjho3bpTCwqopPDxCsbFLlJqaqubNW0qSxowZoaCg4nrxxT4qUKCAQkJCHfb39i4qSfby1NRUffjhB3rooYYKDAzUhQsX9OmnsUpMTNAjjzSVJBUp4q1WrdoqJmauihcvqZIlS2rJkkWSZK9zryNJBwAAAADctSZNHtOFC8maN2+2zOYkhYZW0eTJ0+Xvf2O4+7lzZ2U03vk0aEajUceOHdWaNat08eIFFSvmo/Dwapo5832FhFSy13vppX4ymUwaM2aErl+/rmrVIjR16iwVK1bM6X10BYPNZrO5OghXSEy8rHu15x4eRvn5FZHmNJTO7MxeY9XbSW3nqf3K9tpn3petpsL9wxXbMlbJyVeVkWHNXlwAAAAAkEcYDFJgYNE7qsuddAAAAACA0xmNBhmNBqe1Z7Xa7LO752Uk6QAAAAAApzIaDfL3LSiDyXkpp82SIfOFa3k+USdJBwAAAAA4ldFouJGgxz0vJR7MfoOBVWRoO09Go4EkHQAAAACALEk8mP15tPKZO59qDwAAAAAA5CiSdAAAAAAA3ARJOgAAAAAAboIkHQAAAAAAN0GSDgAAAACAm3BKkm6xWLRv3z5dvHjRGc0BAAAAAJAvZSlJHzdunJYvXy7pRoLeqVMnPfXUU2rUqJF+/fVXpwYIAAAAAEB+kaUk/auvvlJYWJgk6dtvv9XJkye1Zs0adenSRVOmTHFqgAAAAAAA5BdZStKTk5MVFBQkSfr+++/1xBNPqGLFimrbtq0OHjzo1AABAAAAAMgvspSkBwYG6vDhw7JYLPrxxx/10EMPSZKuXbsmk8nk1AABAAAAAMgvPLKyU5s2bfTKK68oKChIBoNBUVFRkqSdO3cqJCTEqQECAAAAAJBfZClJ79u3rypXrqyzZ8/qiSeekJeXlyTJZDKpR48eTg0QAAAAAID8IktJuiQ98cQTkqTr16/by5566qnsRwQAAAAAQD6VpWfSLRaLZs6cqQYNGqh27do6ceKEJOndd9+1L812NxYvXqzGjRurevXqateunXbt2nVH+3355ZeqWrWqevfufdfHBAAAAADA3WQpSZ81a5Y+++wzDR48WJ6envbyKlWq6JNPPrmrtlavXq0JEybopZde0meffaawsDB1795dSUlJt93v5MmTevPNN1W3bt2sdAEAAAAAALeTpST9888/15gxY/Tkk0/KaPyriapVqyo+Pv6u2po/f77at2+vtm3bKjQ0VKNHj1bBggUVFxd3y30sFosGDRqkvn37qmzZslnpAgAAAAAAbidLSfq5c+dUrly5m8ptNpsyMjLuuJ20tDTt3bvXPju8JBmNRkVFRWnHjh233G/mzJkKCAhQu3bt7i5wAAAAAADcWJYmjgsNDdXWrVtVpkwZh/K1a9cqPDz8jttJTk6WxWJRQECAQ3lAQMAt78hv3bpVn3zyiVasWHHXcQMAAAAA4M6ylKT37t1br776qs6dOyebzaavv/5af/zxh1asWKE5c+Y4O0a7K1euaMiQIRozZoz8/f1z7DgAAAAAALhClpL0pk2bavbs2Zo5c6YKFSqkadOmqVq1apo9e7YeeuihO27Hz89PJpPppknikpKSFBgYeFP9EydO6NSpU+rVq5e9zGq1SpKqVaumtWvXZjoMHwAAAACAe0GW10mvW7eu5s+fn62De3l5KSIiQps2bVLTpk0l3Ui6N23apE6dOt1UPyQkRCtXrnQoe/fdd3X16lUNHz5cJUuWzFY8AAAAAAC4UpaTdGfp1q2bhg4dqsjISNWoUUMLFy5Uamqq2rRpI0kaMmSISpQooYEDB6pAgQKqUqWKw/7FihWTpJvKAQAAAAC419xxkv7AAw9o7dq18vf31/333y+DwXDLups3b77jAJo1ayaz2axp06YpISFB4eHhmjdvnn24+5kzZxyWeQMAAAAAIK+64yQ9Ojpa3t7e9u9vl6TfrU6dOmU6vF2SFi1adNt9J06c6LQ4AAAAAABwpTtO0p966in7938ORQcAAAAAAM6TpXHk4eHhN83ILt1Y9/xu1kkHAAAAAAB/yVKSbrPZMi1PS0uTp6dntgICAAAAACC/uqvZ3T/88ENJksFg0PLly1W4cGH7NqvVqi1btigkJMS5EQIAAAAAkE/cVZK+YMECSTfupC9btsxh1nVPT08FBwdr9OjRTg0QAAAAAID84q6S9A0bNkiSOnfurBkzZsjHxydHggIAAAAAID+6qyT9T/+0LBoAAAAAALh7d5ykT5gwQf369VPhwoU1YcKE29aNjo7OdmAAAAAAAOQ3d5yk//7778rIyLB/fysGgyH7UQEAAAAAkA/dcZL+9yHuDHcHAAAAAMD5srROOgAAAAAAcL47vpPep0+fO250xowZWQoGAAAAAID87I6T9KJFi+ZkHAAAAAAA5Ht3Nbs7AAAAAADIOTyTDgAAAACAm7jjO+lPPfWUFixYIB8fH7Vu3fq2S6199tlnTgkOAAAAAID85I6T9CZNmsjLy0uS1LRp0xwLCAAAAACA/CpLs7vfzUzvAAAAAADgztxxkp6Z3bt368iRI5Kk0NBQRUZGOiUoAAAAAADyoywl6WfPntWAAQO0fft2FStWTJJ06dIl1a5dW1OmTFHJkiWdGiQAAAAAAPlBlmZ3Hz58uDIyMrR69Wpt3rxZmzdv1urVq2Wz2TR8+HBnxwgAAAAAQL6QpTvpW7Zs0bJlyxQSEmIvCwkJ0WuvvaaOHTs6LTgAAAAAAPKTLN1JL1WqlDIyMm4qt1qtKl68eLaDAgAAAAAgP8pSkj548GCNGTNGu3fvtpft3r1b48aN09ChQ50WHAAAAAAA+ckdD3e///77ZTAY7K9TUlLUvn17mUwmSZLFYpHJZNKwYcNYRx0AAAAAgCy44yR92LBhORkHAAAAAAD53h0n6U899VROxgEAAAAAQL6Xpdnd/+769etKT093KPP29s5uswAAAAAA5DtZStJTUlI0adIkrVmzRhcuXLhp+759+7IbFwAAAAAA+U6WZnd/++239csvv2jUqFHy8vLS2LFj1bdvXxUvXlxvvvmms2MEAAAAACBfyFKS/u2332rkyJF6/PHHZTKZVLduXfXu3Vv9+/fXypUrnR0jAAAAAAD5QpaS9IsXL6ps2bKSbjx/fvHiRUnSfffdp61btzovOgAAAAAA8pEsJenBwcE6efKkJCkkJERr1qyRdOMOe9GiRZ0XHQAAAAAA+UiWkvS2bdtq//79kqSePXtq8eLFql69uiZMmKDu3bs7NUAAAAAAAPKLLM3u3rVrV/v3UVFRWr16tX7//XeVK1dOYWFhzooNAAAAAIB8JdvrpEs3hr8HBwc7oykAAAAAAPKtLCfpmzZt0oIFC3TkyBFJUqVKldSlSxdFRUU5LTgAAAAAAPKTLD2TvnjxYj3//PMqUqSInnvuOT333HPy9va2P58OAAAAAADuXpbupM+ZM0fR0dHq1KmTQ3mdOnU0e/ZsdezY0SnBAQAAAADyj8UHCytmfxElpBoV5peu1++7rBoB6ZnW/eKLz7R27ZeKj78xurtq1XC98EJvVasWaa9jNidp1qzp2rz5F125clk1a9ZR//6DVbZsOXudPn166rfftju03apVGw0ePCwHevjPspSkX758WQ0aNLip/KGHHtKkSZOyHRQAAAAAIH9ZfaygJuwoqtH3X1LNgDQtPFBE3b/109oWiQrIpP6OHdvUtOnjql69hry8Cmjx4oUaMKCPFi2KVVBQcdlsNkVHD5KHh4cmTpysIkWKaNmyxXrlld766KPlKlSokL2tli2f0vPPv2B/XbBgwVzoceayNNy9cePG+uabb24qX79+vRo1apTdmAAAAAAA+cz8A4XVvlKK2oakKtTHotH3X1JBD5vi4gtlWn/kyLFq06adKleuqvLlK2jo0Ndktdq0detmSdKJE8e1d+9uDRz4qsLDI1SuXAUNGhSt69eva926rxzaKliwoAICAu1fRYp453h/b+WO76R/+OGH9u8rVaqk2bNna/PmzapVq5YkaefOndq+fbu6devm9CABAAAAAHlXmkXaa/bUC9Wu2suMBimqRJp2JHreURvXr19TRkaGihXzkSSlp98YJl+gQIG/2jQa5eXlpV27flPLlq3t5d98s0Zff71a/v4Beuihhura9XmX3U2/4yR9wYIFDq+LFSumw4cP6/Dhw/ayokWLKi4uTr1793ZagAAAAACAvC35ulEWm0EBBa0O5QEFLYq/7HVHbbz33nQFBgaqbt0HJEnly1dQiRIlNXv2DA0ePEyFChXSxx8v1vnz55SUlGjf79FHn1DJkqUUGBikI0cOadas6Tp+/JjGj3/beR28C3ecpG/YsCEn4wAAAAAAIEsWLVqg9eu/1vTpc+x3zj08PDRu3NuaOHGMmjVrLJPJpPvue0D/+leUbLa/9m3Vqo39+0qVQhUQEKh+/Xrp1KmTKlMmOLe7kvV10v9k+//eGQyGLLexePFixcTEKCEhQWFhYXr99ddVo0aNTOt+/fXXmj17to4fP66MjAyVL19e3bp1U+vWrbN8fAAAAACA6/gVsMpksCnpmuO0aUnXTAr8n7vr/2vJkkVavHiB3n33PYWGVnbYFhYWrgULlujKlStKT0+Xn5+fevToorCwards78/Z4U+ePOGSJD1LE8dJ0ooVK9SyZUvVqFFDNWrUUMuWLbVixYq7bmf16tWaMGGCXnrpJX322WcKCwtT9+7dlZSUlGl9Hx8f9erVSx9//LG++OILtWnTRsOGDdOPP/6Y1a4AAAAAAFzIyyRF+Kdr09m/hrZbbdKmc16qHZj5EmyStHjxQi1cOE+TJk2/beLt7e0tPz8/nThxXAcO7FODBg/fsu6hQwckSQEBgVnoSfZl6U76/PnzNXXqVHXs2FGvvPKKJGnbtm0aNWqULly4oK5du95VW+3bt1fbtm0lSaNHj9Z3332nuLg49ezZ86b69erVc3jdpUsXrVixQtu2bct0WTgAAAAAgPvrVjVFQ3/xUaR/umoEpGvhgSJKzTCoTcVUSdKQIUPk4+Ovnj1fkiR99NECxcTM0ciRY1WqVCn7c+aFChVW4cKFJUkbNqyTr6+vSpQoqfj4w5o6dbIaNHhYDzzwL0nSqVMn9c03a/Wvfz0kHx8fHTlySNOmvaNatercdFc+t2QpSV+0aJFGjRrlMMS8SZMmqly5sqZPn37HSXpaWpr27t2rF174az06o9GoqKgo7dix4x/3t9ls+uWXX/THH39o0KBBd9sNAAAAAICbaFb+mszXjZq2u6gSrhkV7peueY2SFVjoxnD3M2fOKD39r6HvK1bEKT09Xa+9NtShnW7deqh79xs5ZlJSombMmCKzOUkBAYF64onm6tr1eXtdDw8Pbd26WbGxS3XtWqqKFy+hRo0aq0uX7rnQ48xlKUlPSEhQ7dq1byqvXbu2EhIS7rid5ORkWSwWBQQ4Lk0fEBCg+Pj4W+53+fJlNWzYUGlpaTIajRo5cqQeeuihO+8AAAAAAMDtdKqSok5VUjLdtmjRIiUnX1VGxo1E/ZNPVv5je+3adVC7dh1uub1EiZKaMWNu1oLNIVl6Jr18+fJas2bNTeWrV69WhQoVshvTPypSpIhWrFihTz75RP3799fEiRP166+/5vhxAQAAAADISVm6k963b1/1799fW7ZsUZ06dSRJ27dv1y+//KJ33333jtvx8/OTyWS6aZK4pKQkBQbe+iF9o9Go8uXLS5LCw8N15MgRzZ0796bn1QEAAAAAeYfJlOW5zx1YrTZZrbZ/rugCWUrSH3/8cS1fvlzz58/X+vXrJUkhISFavny5qlW79Yx6/8vLy0sRERHatGmTmjZtKkmyWq3atGmTOnXqdMftWK1WpaWl3V0nAAAAAAD3Bu/islgtKlaskFOas1gtupCc6paJ+l0n6enp6RoxYoR69+6tSZMmZTuAbt26aejQoYqMjFSNGjW0cOFCpaamqk2bGwvKDxkyRCVKlNDAgQMlSXPmzFFkZKTKlSuntLQ0ff/99/riiy80atSobMcCAAAAAHBDBX1lMpr06g+vKv7irecvuxMhPiGa2HCijEZD3kjSPT099fXXX6t3795OCaBZs2Yym82aNm2aEhISFB4ernnz5tmHu585c0ZG419DGlJSUjR69GidPXtWBQsWVEhIiN5++201a9bMKfEAAAAAANxT/MV47TPvc3UYOSpLw92bNm2q9evX39V66LfTqVOnWw5vX7RokcPr/v37q3///k45LgAAAAAA7iRLSXr58uU1c+ZMbd++XRERESpUyPG5gOeee84pwQEAAAAAkJ9kKUn/5JNPVLRoUe3Zs0d79uxx2GYwGEjSAQAAAADIgiwl6Rs2bLB/b7PdeNDeYDA4JyIAAAAAAPKpLC8yt3z5crVo0ULVq1dX9erV1aJFCy1fvtyZsQEAAAAAkK9k6U761KlTtWDBAnXq1Em1atWSJP32228aP368Tp8+rX79+jkzRgAAAAAA8oUsJelLly7VmDFj1KJFC3tZkyZNVLVqVY0ZM4YkHQAAAACALMjScPeMjAxFRkbeVB4RESGLxZLtoAAAAAAAyI+ylKS3atVKS5cuvak8NjZWLVu2zHZQAAAAAADkR1ka7i7dWIbtp59+Us2aNSVJu3bt0unTp9W6dWtNmDDBXi86Ojr7UQIAAAAAkA9kKUk/ePCgqlWrJkk6fvy4JMnX11e+vr46ePCgvR7LsgEAAAAAcOeylKQvWrTI2XEAAAAAAJDvZXmddAAAAAAA4Fwk6QAAAAAAuAmSdAAAAAAA3ARJOgAAAAAAboIkHQAAAAAAN0GSDgAAAACAmyBJBwAAAADATZCkAwAAAADgJkjSAQAAAABwEyTpAAAAAAC4CZJ0AAAAAADcBEk6AAAAAABugiQdAAAAAAA3QZIOAAAAAICbIEkHAAAAAMBNkKQDAAAAAOAmSNIBAAAAAHATJOkAAAAAALgJknQAAAAAANwESToAAAAAAG6CJB0AAAAAADfh4eoA8pK4uFgtXbpIZnOSKlWqrP79B6tatchM637xxWdau/ZLxccfkSRVrRquF17o7VDfZrMpJmaOVq78TJcvX1H16jU1aNCrqlixgiTp1xNpem55yUzbX/5YomoEZDi3gwAAAACAHMWddCdZv/5rzZgxRd269VBMzEcKDa2iAQP6KjnZnGn9HTu2qWnTxzV9+mzNmTNfJUqU0IABfZSQcN5eZ/Hihfrkk2UaNChac+cuUKFCBTVgQF9dv35dklS7tKc2tj7v8NWuUoqCi2Souj8JOgAAAADca0jSnWTZssVq2bK1mjd/UhUrhmjw4GgVLFhQq1Z9kWn9kSPHqk2bdqpcuarKl6+goUNfk9Vq09atmyXduIu+fPlSPfdcdzVo0EihoZX12mtvKCkpQT/88J0kyctkUFAhq/3Lt4BV608WUJuQVBkMudVzAAAAAICzkKQ7QXp6ug4e3K+6devZy4xGo+rWfUB79+66ozauX7+mjIwMFSvmI0k6ffqUkpKSdP/9D9jreHt7q1q1SO3enXmbG04V0IU0o9qGpGajNwAAAAAAVyFJd4KLFy/IYrHI39/fodzf319JSUl31MZ7701XYGCg6ta9kZSbzTf28/MLcKjn5+evpKTETNv45Ehh1S+ZppKFrXfbBQAAAACAGyBJdwOLFi3Q+vVfa/z4SSpQoECW2jibYtTGs156ulKKk6MDAAAAAOQWknQn8PHxlclkktnsOEmc2WxWQEDALfa6YcmSRVq8eIGmTJmh0NDK9nJ//xv7JSc73olPTjYrICDwpnbi4gvJ18uqxmWuZ7UbAAAAAAAXI0l3Ak9PT1WpEqZt2zbby6xWq7Zt26KIiBq33G/x4oVauHCeJk2arrCwag7bSpcuo4CAAG3dusVedvXqFf3++x5Vr+7Yps0mfRpfSK0rXpMnZxQAAAAA7lmsk+4kHTp01LhxoxQWVk3h4RGKjV2i1NRUNW/eUpI0ZswIBQUV14sv9pEkffTRAsXEzNHIkWNVqlQp+3PmhQoVVuHChWUwGNSu3X+0cGGMypYtq1KlymjevFkKCAhSw4aNHI79yzkvnbzqoacrJedqnwEAAAAAzkWS7iRNmjymCxeSNW/ebJnNSQoNraLJk6fbh62fO3dWRuNft7lXrIhTenq6XnttqEM73br1UPfuL0iSOnbsomvXrumtt8brypXLql69liZPnnbTc+ufxBdS7cA0VSpmyeFeAgAAAAByEkm6E7Vt+4zatn0m020zZsx1eP3JJyv/sT2DwaDnn39Rzz//4m3rTY66eOdBAgAAAADcFkl6LjEaDTIaDU5py2TiwXMAAAAAyIvcIklfvHixYmJilJCQoLCwML3++uuqUSPzCddiY2O1YsUKHTp0SJIUERGhAQMG3LK+OzAaDfLxLSwPkmsAAAAALhYXF6ulSxfJbE5SpUqV1b//YFWrFplp3fj4I4qJma0DB/br7NkzevnlAWrf/lmHOhaLRR98MFdff71GSUlJCgwMVIsWT2rAgH768zblq7/46LM/CjnsV7/kdcU8wrxa/8vlSfrq1as1YcIEjR49WjVr1tTChQvVvXt3rV27NtPly3799Vc1b95cderUkZeXl+bNm6f//ve/+vLLL1WiRAkX9OCfGY0GeZiM6rdshw6fv5Lt9hpVDdLgx8OcEBkAAACA/GT9+q81Y8YUDRoUrWrVIhUbu1QDBvTV0qVx8vPzv6n+9evXVLp0sB55pKmmT38n0zYXL16oFSs+0fDho1WxYoj27/9dEya8oaAgfz33t3oNSl3XhHp/ParrZbI5u3t5gsuT9Pnz56t9+/Zq27atJGn06NH67rvvFBcXp549e95Uf/LkyQ6vx44dq6+++kqbNm1S69atcyPkLDt8/or2nr6U7XYqBRVxQjQAAAAA8ptlyxarZcvWat78SUnS4MHR2rRpo1at+kKdO3e9qX54eITCwyMkSbNnz8i0zT17dql+/YcVFVVfklSqVGmtX/+1du3aJVX+q56X0aagQlbndigPcun467S0NO3du1dRUVH2MqPRqKioKO3YseOO2khNTVVGRoZ8fHxyKkwAAAAAuOelp6fr4MH9qlu3nr3MaDSqbt0HtHfvriy3GxlZQ9u2bdHx48ckSYcOHdTOnb+pYcOGDvU2n/fSg58G6fFVgRq5pZiSrztnzq68xqV30pOTk2WxWG4a1h4QEKD4+Pg7amPSpEkqXry4Q6IPAAAAAHB08eIFWSwW+fs7Dmv39/fXsWNHs9xup05ddfXqVXXs+LSMRqOsVqtefPElPfnkk9KcSZJuDHV/NPiagr0tOnHFpHd2FlWP7/z08aNmMXWXI5cPd8+OuXPnavXq1frwww9vWjscAAAAAJDzNmz4Rt98s1YjR45VxYqVdOjQAU2b9o7Klw/WU/9fp3n5a/b6VX0zVNU3Q01XBt24u14yzTWBuymXJul+fn4ymUxKSkpyKP9zRsDbiYmJ0dy5czV//nyFhTGJGgAAAADcjo+Pr0wmk8xms0O52WzOdNLuO/Xee9PUsWMXNW36uCSpUqVQnT9/TnPmzNFTT2W+T1lvi/wKWHXsikkPZvnIeZNLBxZ4eXkpIiJCmzZtspdZrVZt2rRJtWvXvuV+77//vt577z3NmzdP1atXz41QAQAAAOCe5unpqSpVwrRt22Z7mdVq1bZtWxQRkfUlra9duyaj0TG1NJmMstluPXv72RSjLlw3KKggE8n9L5cPd+/WrZuGDh2qyMhI1ahRQwsXLlRqaqratGkjSRoyZIhKlCihgQMHSroxxH3atGmaPHmyypQpo4SEBElS4cKFVaQIs54DAAAAwK106NBR48aNUlhYNYWHRyg2dolSU1PVvHlLSdKYMSMUFFRcL77YR9KNyeaOHo23f5+QkKBDhw6oUKHCCg4uK0l66KEG+vDDD1SiRElVrBiigwcPaOnSj/T0009LWqmr6QbN2OOtx8teU2BBq05cMent34qqfFGLGpS67pL3wZ25PElv1qyZzGazpk2bpoSEBIWHh2vevHn24e5nzpxxuCqzbNkypaen6+WXX3Zop0+fPurbt2+uxg4AAAAA95ImTR7ThQvJmjdvtszmJIWGVtHkydPl739juPu5c2cd8q/ExAR169bR/nrp0kVaunSRatWqoxkz5kqS+vcfrPffn63JkycqOTlZgYGBat26rfr16yfNXymTwaaDFzy04g9fXU43qnghqx4qeV39ql+Rlyl3+38vcHmSLkmdOnVSp06dMt22aNEih9cbNmzIjZAAAAAAIE9q2/YZtW37TKbb/ky8/1SqVGlt3Lj1tu0VLlxE/foNVL9+A+1lHh5GeXl5SZIKekgxjyRnM+r8wy2SdAAAAACA6xmNBhmN2V+/3MS6allGkg4AAAAAkNFokI9vYXmQYLsUSToAAAAAQEajQR4mo/ot26HD569kq61GVYM0+HGWys4KknQAAAAAgN3h81e09/SlbLVRKYiVt7KKcQwAAAAAALgJknQAAAAAANwESToAAAAAAG6CJB0AAAAAADdBkg4AAAAAgJsgSQcAAAAAwE2QpAMAAAAA4CZI0gEAAAAAcBMk6QAAAAAAuAmSdAAAAAAA3ARJOgAAAAAAboIkHQAAAAAAN0GSDgAAAACAmyBJBwAAAADATZCkAwAAAADgJkjSAQAAAABwEx6uDgAAAAB5S1xcrJYuXSSzOUmVKlVW//6DVa1aZKZ14+OPKCZmtg4c2K+zZ8/o5ZcHqH37Zx3qLFo0X99//62OHTuqAgUKqHr1GurVq6/Klatgr5OUlKj33puqLVs2KyXlqsqVK6/nnvuvGjVqkpNdBQCn4046AAAAnGb9+q81Y8YUdevWQzExHyk0tIoGDOir5GRzpvWvX7+m0qWD9eKLfRQQEJBpnR07tqtNm3aaM2e+pkyZqYyMDPXv30epqan2OmPHjtTx48c0ceJkLVy4TA0bPqIRI6J18OD+HOknAOQUknQAAAA4zbJli9WyZWs1b/6kKlYM0eDB0SpYsKBWrfoi0/rh4RF66aV+atr0cXl6emVa5513pqtZs5YKCamkypWraNiwUTp37qwOHNhnr7Nnzy61bfuMqlWLVJkywera9Xl5exfVgQMk6QDuLSTpAAAAcIr09HQdPLhfdevWs5cZjUbVrfuA9u7d5bTjXL16RZJUrFgxe1lkZA1t2PCNLl26KKvVqnXrvlJa2nXVrn2f044LALmBZ9IBAADgFBcvXpDFYpG/v79Dub+/v44dO+qUY1itVk2bNlnVq9dUSEiovfyNNyZq5MhoNWvWRCaTSQULFtT48ZMUHFzWKccFgNxCkg4g33D2REa//bZdS5Ys0oED+5SUlKjx4yepYcNGDnXM5iTNmjVdmzf/oitXLqtmzTrq33+wypYtl1PdBIA87Z133lR8/BG99948h/J582bp8uXLevfd9+Tj46sff/xOI0a8qpkz56lSpdBM2wIAd8RwdwD5Qk5MZJSamqrQ0MoaMGBoptttNpuiowfp9OlTmjhxsubPX6ySJUvqlVd6O0x2BAB5hY+Pr0wmk8xmx9+tZrP5lr9L78Y777ypn3/eqGnTZqt48RL28lOnTiouLlbR0SNUt+4Dqly5iv77356qWrWaPv00NtvHBYDcRJIOIF/IiYmMHnzwIfXs2VsPP/xIpttPnDiuvXt3a+DAVxUeHqFy5Spo0KBoXb9+XevWfeW0vgGAu/D09FSVKmHatm2zvcxqtWrbti2KiKiR5XZtNpveeedN/fDDd5o6dZZKly7jsP3atWuSbjz//ncmk1FWqy3LxwUAVyBJB5Dn5dZERpkdV5IKFCjgcFwvLy/t2vVbjh0XAFypQ4eOWrlyhdasWaWjR//QpEkTlJqaqubNW0qSxowZodmzZ9jrp6en69ChAzp06IDS09OVkJCgQ4cO6OTJE/Y6kye/qa+/XqORI8eqcOHCSkpKVFJSoq5fv5Gcly9fQcHBZfX22+P1++97dOrUSS1d+pG2bPlVDRs+nLtvAABkE8+kA8jzcmMio8yUL19BJUqU1OzZMzR48DAVKlRIH3+8WOfPn1NSUmKOHRcAXKlJk8d04UKy5s2bLbM5SaGhVTR58nT5+98Y7n7u3FmHO96JiQnq1q2j/fXSpYu0dOki1apVRzNmzJUkrVjxiSSpb98XHI41bNhINWvWUh4eHnr77amaPXu6hg4doNTUFJUpU1bDh4/Sgw/Wz+kuA4BTkaQDQA7x8PDQuHFva+LEMWrWrLFMJpPuu+8B/etfUbIx+hJAHta27TNq2/aZTLf9mXj/qVSp0tq4cett2/un7ZJUtmw5jRv39p0HCQBuiiQduAVnzwR+J20mJSXqvfemasuWzUpJuapy5crruef+q0aNmuRYP/ODnJ7I6HbCwsK1YMESXblyRenp6fLz81OPHl0UFlYtR48LAACAexPPpAOZyImZwO+kzbFjR+r48WOaOHGyFi5cpoYNH9GIEdE6eHB/jvQzv8ipiYzuhre3t/z8/HTixHEdOLBPDRrwjCSA/MtoNMjDw+iUL6PR4OruAIBTcScdyMTfZwKXpMGDo7Vp00atWvWFOnfuelP98PAIhYdHSJLDZDh32+aePbs0cOCr9rvrXbs+r9jYpTpwYL+qVAlzci/zlw4dOmrcuFEKC6um8PAIxcYuuWkio6Cg4nrxxT6SbkxkdPRovP37PycyKlSosIKDy0qSUlJSdOrUXxMbnTlzSocOHVDRoj4qWbKkJGnDhnXy9fVViRIlFR9/WFOnTlaDBg/rgQf+lZvdBwC3YTQa5ONbWB4m59wryrBYdfFCCrO4A8gzSNKB//HnTOCdO3ezl2V3JvA7bTMysoY2bPhGUVH15e1dVBs2fKO0tOuqXfu+rHcIknJmIqP9+3/Xyy+/aK8zffoUSdK//91Cw4ePknTjEYYZM6bIbE5SQECgnniiubp2fT6nuwsAbstoNMjDZFS/ZTt0+PyVbLUVWtxbUzvUltFoIEkHkGeQpAP/IydmAr/TNt94Y6JGjoxWs2ZNZDKZVLBgQY0fP8l+5xbZ4+yJjOrUqfuPddq166B27TrcXaAAkA8cPn9Fe09fcnUYAOB2SNIBNzJv3ixdvnxZ7777nnx8fPXjj99pxIhXNXPmPFWqFOrq8AAAAADkMJJ04H/kxEzgd9LmqVMnFRcXqw8//FghIZUkSZUrV9HOnb/p009jNXjwsCwdG3fGaDQ4bfIhq9XGsEsAAABkCUk68D/+PhN4w4aNJP01E3ibNu1zrM1r165JksNz0ZJkMhlJ+HIYkxgBAADAXZCkA5nIiZnA/6nN8uUrKDi4rN5+e7xeeqmffHx89cMP32nLll/11ltTXPAu5B9MYgQAAAB3QZIOZCInZgL/pzY9PDz09ttTNXv2dA0dOkCpqSkqU6ashg8fpQcfrJ+Lvc+/mMQIAIDMxcXFaunSRTKbk1SpUmX17z/YvmRsZjZsWKd582bp7NkzCg4uq169+jr8f8ZsTtKsWdO1efMvunLlsmrWrKP+/QerbNlykqRLly4qJmaONm/+RefOnZOvr68aNmyk55/vJW9v7xzvL+BKJOnALTh7JvB/alOSypYtp3Hj3r67QAEAAHLQ+vVfa8aMKRo0KFrVqkUqNnapBgzoq6VL4+Tn539T/d27d2r06OF64YWXFBXVQN98s1bR0YP0wQcfKSQkVDabTdHRg+Th4aGJEyerSJEiWrZssV55pbc++mi5ChUqpMTEBCUmJuill15RxYohOnv2jN5+e4ISExM0duxbLngXgNzjnAcwAQAAAORJy5YtVsuWrdW8+ZOqWDFEgwdHq2DBglq16otM6y9fvkz16j2oZ599ThUqVFSPHr1UpUqY4uJiJUknThzX3r27NXDgqwoPj1C5chU0aFC0rl+/rnXrvpIkhYSEaty4t1W/fkOVKROs++67Xz179tZPP/2ojIyMXOs74Aok6UAWGY0GeXgYnfLlrFnFAQAAnCk9PV0HD+5X3br17GVGo1F16z6gvXt3ZbrPnj27VLfuAw5l9eo9qD17dtvblKQCBQo4tOnl5aVdu367ZSxXr15RkSJF5OHBYGDkbS7/CV+8eLFiYmKUkJCgsLAwvf7666pRo0amdQ8dOqRp06Zp7969OnXqlKKjo9W1a9fcDRgQs4ED7sDZz0empKRo9uzp+vHH73Xx4kWVLl1aTz/9jFq3ftpep0+fnvrtt+0O7bZq1YYlEgHkWRcvXpDFYpG/v+Owdn9/fx07djTTfczmpJuGwfv5+ctsTpJ0Y7LcEiVKavbsGRo8eJgKFSqkjz9erPPnzykpKTHTNi9cuKAFC+apZcunst8pwM25NElfvXq1JkyYoNGjR6tmzZpauHChunfvrrVr12a6HnVqaqqCg4P1xBNPaMKECS6IGLiB2cAB13L285GSNH36FG3fvkWvv/6GSpUqrc2bf9E777ypwMAg1a//sL2tli2f0vPPv2B/XbBgwZzvMADkIR4eHho37m1NnDhGzZo1lslk0n33PaB//StKtkz+K3T16hUNHtxPFSqEqHv3F26uAOQxLk3S58+fr/bt26tt27aSpNGjR+u7775TXFycevbseVP9GjVq2O+yT548OVdjBTLDbOCAa/z9+UhJGjw4Wps2bdSqVV+oc+euN9X/+/ORktSjRy9t2fKr4uJi7XfB9+zZqX//u4Xq1Kkr6cYd8s8//1S//77XIUkvWLCgAgICc7iHAOAefHx8ZTKZZDabHcrNZnOmN9Ukyd8/QMnJjvWTk832FW0kKSwsXAsWLNGVK1eUnp4uPz8/9ejRRWFh1Rz2S0m5qoEDX1bhwkU0fvzbDHVHvuCyZ9LT0tK0d+9eRUVF/RWM0aioqCjt2LHDVWEBANxcTjwfKUmRkTW1ceMPSkg4L5vNpu3bt+rEieN64IF/Oez3zTdr1Lx5E3Xu3F6zZ8/QtWvXnNg7AHAvnp6eqlIlTNu2bbaXWa1Wbdu2RRERmT+iGhlZQ1u3bnEo27LlV0VGVr+prre3t/z8/HTixHEdOLBPDRr8dVH06tUr6t+/jzw8PPTmm+84PMMO5GUuuxSVnJwsi8Vy0xW4gIAAxcfHuygqAIC7y4nnIyWpf//BeuutcXrqqWYymUwyGo0aMmS4atWqY6/z6KNPqGTJUgoMDNKRI4c0a9Z0HT9+TOPHs3QigLyrQ4eOGjdulMLCqik8PEKxsUuUmpqq5s1bSpLGjBmhoKDievHFPpKkdu06qE+fnlq69CNFRdXXunVfaf/+3zVkyF/zd2zYsE6+vr4qUaKk4uMPa+rUyWrQ4GH7hdE/E/Tr169pxIgxunr1iq5evfGIoa+vn0wmUy6/C0DuYbwIAACSPvnkY+3du1sTJ76jkiVLaefO7XrnnbcUGBik+++/cde+Vas29vqVKoUqICBQ/fr10qlTJ1WmTLCrQs8TnD0RYP36dTPdr3fvl+2PPUjSzz9v1Pz57+vIkcPy8vJS7dp1NGECj9QBf9ekyWO6cCFZ8+bNltmcpNDQKpo8ebp9+Pq5c2dlNP41QLd69ZoaOXKc3n//Pc2dO1PBwWU1YcIk+xwgkpSUlKgZM6bIbE5SQECgnniiubp2fd6+/cCB/fr99z2SpGeeae0Qz/LlX6hUqdI52GPAtVyWpPv53bgClpSU5FCelJSkwECe9QMAZC4nno+8fv2a5s6dqfHjJykq6kaiFxpaWYcOHdTSpR/Zk/T/9WcSefLkCZL0bMiJiQA//3ytwz6//PKzJk4co4cfbmwv++679XrzzXF64YXeqlPnflksFsXHH8nZzgL3qLZtn1Hbts9kum3GjLk3lTVu3FSNGze9ZXvt2nVQu3Ydbrm9Tp262rhx690HCuQBLnsm3cvLSxEREdq0aZO9zGq1atOmTapdu7arwgIAuLmceD4yIyNDGRkZMhgMDnWMRqNsNustYzl06IAkMZFcNv19IsCKFUM0eHC0ChYsqFWrvsi0/t8nAqxQoaJ69OilKlXCFBcXa68TEBDo8LVx4/eqU6eu/WJKRkaGpk6drJdeelmtWz+tcuXKq2LFEDVp8miu9BkAgFtxWZIuSd26dVNsbKw+++wzHTlyRKNGjVJqaqratLkxnHDIkCEOs7inpaVp37592rdvn9LS0nTu3Dnt27dPx44dc1UXAAAu0KFDR61cuUJr1qzS0aN/aNKkCTc9Hzl79gx7/XbtOujXX3/W0qUf6dixo4qJmaP9+39X27btJUlFinirVq06eu+9qdq+fatOnz6l1atXau3a1WrY8BFJ0qlTJ7VgwTzt379PZ86c1saN32vs2JGqVauOQkMr5/6bkEfk1ESAf2c2J+nnnzeqefNW9rKDB/crIeG8DAajunV7Vq1aPa6BA19WfPxhJ/QKyF+MRoM8PIxO+TIaDf98QCCPc+kz6c2aNZPZbNa0adOUkJCg8PBwzZs3zz7c/cyZMw7Pt5w/f16tW7e2v/7ggw/0wQcf6IEHHtCiRYtyO3wAgIvkxPORo0eP15w5M/XGG6/r0qVLKlmypHr27KXWrW8sE+rh4aGtWzcrNnaprl1LVfHiJdSoUWN16dI9dzufx+TURIB/t2bNKhUuXEQPP/yIvez06VOSpA8+mKu+ffurZMnSWrbsI/Xt+4KWLv1UxYr5ZKNXQP5hNBrk41tYHibn3PvLsFh18UKKrNZMFkwH8gmXTxzXqVMnderUKdNt/5t4BwcH68CBA7kRFgDAzTn7+ciAgEANGzbylttLlCiZabtwf19++YUee+wJh+Wb/kwAnnvuv2rUqIkkadiwkWrTppk2bFhnvzgD4PaMRoM8TEb1W7ZDh89fyVZbocW9NbVDbRmNBpJ05GsuT9IBAHA2o9HgtCGTVquN/yzmoJyYCPDvdu7coePHj2n06AkO5X+O2qtQIcRe5uXlpVKlyujcubNZ6guQnx0+f0V7T19ydRhAnkCSDgDIUxh6eW/5+0SADRs2kvTXRIBt2rTPdJ8/JwJs3/5Ze9nfJwL8u1WrPlfVquGqXLmKQ3nVqmHy8vLSiRNHVbNmLUk3JpM7e/aMSpYs5ZzOAQCQBSTpAIA8haGX954OHTpq3LhRCgurpvDwCMXGLrlpIsCgoOJ68cU+km5MBNinT08tXfqRoqLqa926r7R//+8aMmSYQ7tXr17Rt9+uU58+r9x0zCJFvNWqVVvFxMxV8eIlVbJkSS1ZcuMxu0ceufVjEQAA5DSSdABAnsTQy3tHTkwEKEnr1n0tm82mpk2fyPS4L73UTyaTSWPGjND169dVrVqEpk6dpWLFiuVcZwEA+Ack6QAAwOWcPRGgJLVq1UatWrW55XYPDw/16fNKpnfaAQBwFZJ0AADg1pw5EaDEZIAAAPdGkg4AANyWsycClJgMEADg3kjSAQCA23LmRIASkwECANwfSToAAHB7TAQIAMgvnDd2DAAAAAAAZAtJOgAAAAAAboIkHQAAAAAAN0GSDgAAAACAmyBJBwAAAADATTC7OwAAThYXF6ulSxfJbE5SpUqV1b//YFWrFnnL+hs2rNO8ebN09uwZBQeXVa9effXgg/Xt22Ni5mj9+q91/vw5eXh4qmrVcPXs2VsREX+1efz4Mb333lTt3r1T6ekZqlQpVD169FKdOnVztK8AAMC5uJMOAIATrV//tWbMmKJu3XooJuYjhYZW0YABfZWcbM60/u7dOzV69HC1aNFKH3ywWA0aNFJ09CDFxx+21ylbtrz69x+ihQuX6b335qlUqVIaMOAlJScn2+sMGdJfFotFU6fOVkzMIoWGVtGQIa8oKSkxx/sMAACchyQdAAAnWrZssVq2bK3mzZ9UxYohGjw4WgULFtSqVV9kWn/58mWqV+9BPfvsc6pQoaJ69OilKlXCFBcXa6/z2GNP6P7766lMmWCFhFRS3779dfXqVR05ckiSdOHCBZ08eVydOnVVaGhllS1bTr169dG1a9cUH38kV/oNAACcgyQdAJDvGeM3yuurMfL6fIg8v3tXBvOx29bfsGGdnn22rRo3jtJzzz2jTZs2SpLS09N18OB+XbhwQc8+21ZNm9ZXs2ZNZLVa9csvP2Xa1p49u3Tw4AHVr19Xhw4dkCTVq/eg9uzZnWn99PR0ff75Z/L29lZoaBVJko+Pj8qVK6+1a79UamqqMjIytGLFp/Lz81fVquFZfVsAAIAL8Ew6ACBfM57cIY/dnyujVjvZ/MrJdOQHef48V2mPviqp2E31/xye/sILLykqqoG++WatoqMH6YMPPlKxYj6yWCwqX76iWrZsrdKly+j69esaNWq4du/eqeTkZPn5+Tm0l5CQoEqVKikxMcFe5ufnL7M5yaHeTz/9qFGjhunatWsKCAjUlCkz5evrK0kyGAx69933FB09SI891lBGo1G+vn6aPHmaihW7uQ8AAMB9cScdAJCvmQ5/L2uFf8la/gHZipVURq2nJZOnTEc3Z1r/Toan16v3L4fh6ffdV1dWq9U+PP1Pmzb9JJvNqsce+/c/xlmnTl3Nn79Es2Z9oHr1HtSIEdH259xtNpveeedN+fn5aebM9zV37kI1aNBIQ4cOUGIiz6QDAHAvIUkHAORf1gwZLpyUNajKX2UGo6xBVWQwH810lz17dqlu3Qccyv4cnu7j4yuTySSz+a9J4tLT07Vr106ZTCb78HRJMpuT9NZb4+Tv76+UlKsO7SUnm+XvH+BQVqhQIQUHl1VkZHVFR4+QyWTSqlWfS5K2bduin3/eqNGjx6tGjVqqWjVMgwa9qgIFCmjNmlVZeWcAAICLMNwdAJB/Xb8qg80qW4GiDsW2gkVlvHI+013M5iT5+fk7lP05PN3T01NVqoRp27bNMplMGjVqmFJTU2U0GtW6dVv78HSbzaZx40arVas2io8/ot27dzm0t2XLr4qMrH7b0K1Wq9LS0iRJ165dkyQZDI7X3g0Gg2w26+3fAwAA4Fa4kw4AgBN16NBRK1euUGJigsaOfVMNGjwso9GkjRt/UHKyWWPGjFD//i8pJeWqOnfupnbtOui337ZLks6cOa2YmDnav/93tW3bXpKUmpqqOXNmas+e3Tp79oz279+n8eNHKzExQY880lSSFBlZQ0WLFtW4cSN16NBBHT9+TDNnTtWZM6cd1lsHAADujzvpAID8q0AR2QxGGa5flu1vxYZrl2+6u/4nf/+Am9Y8//vw9CZNHtOFC8n68MMPZDYnKTS0imbOfF9jxryuVas+17lzZ3X69CklJiaoceMoSTfurEvSsGGD5e3trQkTJikkJFSSZDQadezYUa1Zs0oXL15QsWI+Cg+vppkz31dISCVJkq+vryZPnq65c99Tv369lJGRoYoVQzRhwmRVrlxFAADg3kGSDgDIv4wesvkGy5hwSNbS/z+83GaVMeGQLCGZ34GOjKyhrVu3qH37Z+1l/zs8vW3bZ9S27TMO+/05PH3GjLk6e/asUlKu2LclJiZqwIA+Gjv2TVWrFqnixUvYtxUoUEDjx7/9j10JC6umd96ZcUfdBu41xviN8jj0rXTtsmw+pZVR4ynZ/Mvfsv6GDes0b94snT17RsHBZdWrV1/7qJKMjAzNnfuefvnlJ50+fUpFinirbt0H1KtXXwUGBtnbWLgwRps2/aRDhw7I09NTa9d+l9PdBABJDHcHAORzltCHZTz6i4zHtshw6Zw8fvtEsqTJUv7G5HBDhgzRe+9Nt9dv166Dfv31Zy1d+pGOHTuapeHpJUuWVEhIqP2rbNlykqQyZYIdEnQAf1smMexxpT8yQDaf0vL8ea50/XKm9f9cJrFFi1b64IPFatCgkaKjByk+/rCkG3M4HDy4X126PK8PPvhI48a9rePHj2no0AEO7WRkZOiRR5qodeunc7yPAPB33EkHAORr1uDayrh+RR771krXL8nmU0bpUT2lgjeGu585c0bp6X9Nvla9ek2NHDlO77//nubOnang4LJ3NTzdaDTIaDQ4xGAyGe3/enjc+fVzq9Umq9X2zxWBe9jfl0mUpIxaT8vr7O83lkms+NRN9f++TKIk9ejRS1u2/Kq4uFgNHjxM3t7eevfd9xz2GTBgiHr06KKzZ8+qZMmSkqTu3V+QJK1evTInuwcANyFJBwDke9ZKDZRWqUGm2xYtWqTk5KvKyPgrUW/cuKkaN26aaf3bDU83Gg3y9Sskk9HkUO7nV1kHDhy467gtVosuJKeSqCPv+v9lEi1VmvxVdgfLJHbo0NGhrF69B/XDD9/d8jBXrlyRwWBQ0aLeTggaALKHJB0AgH/w551uZ7RjMpr06g+vKv5ifLbaCvEJ0cSGE2U0GkjSkXc5eZnETA9x/bpmzZqupk0fV5EiJOkAXI8kHQCAWwjyLiBZLSpWrJBT242/GK995n1ObRPA3cvIyNCIEa9KsmnQoFddHQ4ASCJJBwDglooV8pCMJinueSnxYPYbDG0qNRmR/XaA/CIHlkn8U0ZGhl5//VWdPXtW06bN4i46ALdBkg4AwD9JPCid2Zn9dgJZsxy4Kzm0TOKfCfrJk8c1bdoc+fj45mQvAOCusAQbAAAA3Jazl0nMyMjQa68N0YED+zRixFhZrRYlJSUqKSlR6enp9nbOnj2rQ4cO6Ny5s7JYrDp06IAOHTqglJSU3H0DAOQ73EkHAACA23L2MokJCee1ceMPkqRu3Z51ONa0abNVp05dSVJMzGytWbPKvq1bt4431QGAnECSDgAAALfmzGUSS5UqrY0bt/7jMYcPH6Xhw0dlKV4AyA6GuwNuJC4uVk8/3VKNG0epR48u+v33Pbetv2HDOj37bFs1bhyl5557Rps2bcyRtpA1nE/AfX3yycdO/UzxGc1bOJ+ux99Q5Gck6YCb+OabrzRjxhR169ZDMTEfKTS0igYM6HvTDLV/2r17p0aPHq4WLVrpgw8Wq0GDRoqOHqT4+MNav/5rp7WFrOF8Au5r9erVmjr1Had9pviMup7JZJSHR/a/jEYD59MN8DcU+R1JOuAmli5drJYtW6t58ydVsWKIBg+OVsGCBbVq1ReZ1l++fJnq1XtQzz77nCpUqKgePXqpSpUwxcXFatky57WFrOF8Au5r/vz5atXqKad9pviMuk6QdwHJalGxYoXk51ck21/+vgX18cecT1fjbyjyO55JB9xAWlqaDhzYp06dutrLjEaj6tZ9QHv37sp0nz17dqlDh44OZfXqPajvv/9Wx479oc6du2W7rR9++C5rHcrnOJ+A+7JZMrR371517NjFXpadz1R6eroOHtzPZ9RFihXykIwmKe75G0slZkdgFaW3fE8HDuxXp06cT1fhbyhAkg64heTkZFksFvn7+zuU+/v769ixo5nuYzYnyc/Psb6fn7+SkhKd1pbZnHR3HYEkzifgzizXrjj1M3Xx4gU+o+4g8aB0Zme2m3Hm72/OZ9bwNxRguDsAAAAAAG6DJB1wA35+fjKZTDKbHScxMZvNCggIyHQff/+AmyY9SU42KyAg0Glt+ftnXh+3x/kE3JepoLdTP1M+Pr58RvMQZ/7+5nxmDX9DAZJ0wC14eXmpatVwbdu22V5mtVq1bdsWRUTUyHSfyMga2rp1i0PZli2/qnr1GqpSJcwpbUVGVs9ql/I1zifgvgwmD0VERGjLFud8pjw9PfmM5iHO/P3N+cwa/oYCJOmA2/jPfzpq5coVWrNmlY4e/UOTJk1QamqqmjdvKUkaM2aEZs+eYa/frl0H/frrz1q69CMdO3ZUMTFztH//72rbtr06dHBeW8gazifgvrp166YvvvjMaZ8pPqN5izN/fyNr+BuK/M4tJo5bvHixYmJilJCQoLCwML3++uuqUSPzq1uStGbNGk2dOlWnTp1ShQoVNGjQID388MO5GDHgfI8++rjMZrPmzZstszlJoaFVNHnydPvwqnPnzspo/Ou6WvXqNTVy5Di9//57mjt3poKDy2rChEkKCQlVSEioLlxIdkpbyBrOJ+C+mjVrppMnzzjtM9WkyWN8RvMQZ/7+RtbwNxT5ncFms9lcGcDq1as1ZMgQjR49WjVr1tTChQu1du1arV27NtNnRbZv365OnTppwIABeuSRR7Ry5UrNmzdPn376qapUqXLHx01MvKzc6rmHh1F+fkXUfNqP2nv6Urbbe7JmKU37Tx1pTsPsz2RavZ3Udp7ar2yvfeZ92Woq3D9csS1jlZx8VRkZ1uzF5eaceU4jShfTly83yBfvm7vifOYtzjyfTv19K/E7Nwuc/TeUz6jrue1ntFRN6YUf+Nm4S/wNzVvc9vMp3fN/Qw0GKTCw6B3Vdflw9/nz56t9+/Zq27atQkNDNXr0aBUsWFBxcXGZ1v/www/VoEEDPf/886pUqZJeeeUVVatWTR999FEuRw4AAAAAgHO5dLh7Wlqa9u7dqxdeeMFeZjQaFRUVpR07dmS6z2+//aauXbs6lNWvX1/r1q27q2MbDHcdbrZFlC6mQl6mbLdTKcj7xjcla0iehbPXWMCNoTvh/uEq5FEoW01VKFbB/r0r3l9XcMY5DQksIkkymZxzzcxmc+77b7PZZLW6dMBNrnHH8yk595xyPu+OU3/fSvzOzQZn/Q1159+5+enzKbnhZ/T/P5/O/f2df84pf0PzFrf7fEr3/N/QuzmOS4e7nzt3Tg0bNtSyZctUu3Zte/lbb72lLVu2aPny5TftExkZqYkTJ6pFixb2ssWLF2vmzJn6+eefcyVuAAAAAABygsuHuwMAAAAAgBtcmqT7+fnJZDIpKSnJoTwpKUmBgYGZ7hMYGKjExMQ7rg8AAAAAwL3CpUm6l5eXIiIitGnTJnuZ1WrVpk2bHIa//12tWrX0yy+/OJT9/PPPqlWrVk6GCgAAAABAjnP5cPdu3bopNjZWn332mY4cOaJRo0YpNTVVbdq0kSQNGTJEkydPttd/7rnn9OOPP+qDDz7QkSNHNH36dO3Zs0edOnVyVRcAAAAAAHAKl87uLknNmjWT2WzWtGnTlJCQoPDwcM2bN88+fP3MmTMyGv+6llCnTh1NmjRJ7777rt555x1VqFBBM2fOvKs10gEAAAAAcEcund0dAAAAAAD8xeXD3QEAAAAAwA0k6QAAAAAAuAmSdAAAAAAA3ARJOgAAAAAAboIkHQAAAAAAN+HyJdjgPBkZGTp8+LASEhIkSUFBQapUqZI8PT1dHBmcLSMjQ+fPn1fp0qVdHQruQkJCgnbu3KnExERJUmBgoGrWrKmgoCAXRwYAAAB3QZKeB1itVk2dOlVLlizR5cuXHbYVLVpUHTt21Msvv+yw3jzubYcPH9ZTTz2lffv2uToU3IGUlBSNGDFCq1evlsFgkI+PjyTp4sWLstlsat68ud544w0VKlTIxZHCGVJSUrR3717df//9rg4Fd4kLaQAAd0CSngdMmjRJn332mQYOHKj69esrMDBQkpSYmKiffvpJU6dOVXp6ugYPHuziSIH8ady4cdq9e7fmzJmjqKgomUwmSZLFYtGmTZs0ZswYjRs3TmPHjnVxpHCG48eP67nnnuMi2j2EC2n5CxfS7k27du3Sjh07HC6i1a5dWzVq1HBxZHC2ixcv6ttvv1Xr1q1dHYrLGGw2m83VQSB7HnroIU2cOFENGjTIdPuPP/6ooUOH6ueff87lyJBVTz311G23X7t2TUePHiUJuEfcf//9mjNnjurUqZPp9m3btunFF1/Uli1bcjky5IT9+/cz0uUeM3z4cG3dulWvvfbaLS+k3X///VxIyyP4jN5bkpKS1LdvX23fvl2lS5dWQECAvfz06dOqU6eOpk+fbi/HvY/PKHfS84SrV6+qePHit9weFBSk1NTUXIwI2XX48GE1b95cwcHBmW4/f/68jh49mrtBIcusVutt54bw9PSU1WrNxYiQHQ888MBtt1ssllyKBM7y9ddfZ3ohzWQyqX79+ho/frxefPFFknTABUaPHi2r1arVq1crJCTEYVt8fLyGDRum0aNHa9q0aS6KEHfrypUr2dqeH5Ck5wEPPPCA3nrrLb399tvy9/d32GY2mzVp0qR//E8l3EvlypVVo0YNPfvss5lu37dvn5YvX57LUSGrGjVqpBEjRmjcuHGqVq2aw7bff/9do0aN0iOPPOKi6HC30tLS9J///EdVqlTJdPupU6c0c+bMXI4K2cGFtLyFC2l5y48//qjFixfflKBLUkhIiF577TV17tzZBZEhq+rWrSuDwXDL7Tab7bbb8wOS9Dxg9OjR6tmzpxo0aKAqVao4DAM6ePCgKlWqpDlz5rg4StyNOnXq6I8//rjl9iJFiqhu3bq5GBGyY8SIERo4cKDatGkjHx8f+8U0s9msS5cuqX79+hoxYoSLo8SdCgsLU8mSJW/5WMr+/ftJ0u8xXEjLW7iQlrd4eXnd9s7q1atX5eXllYsRIbuKFCmiF198UTVr1sx0+7Fjx/L9/4tI0vOAUqVK6fPPP9ePP/7oMCttjRo11L9/f9WvX5+Z3e8xr7322m23lytXTosWLcqlaJBdPj4+mjdvno4cOaLffvvNYdKbWrVqqVKlSi6OEHejUaNGN62k8Xc+Pj75erKbexEX0vIWLqTlLc2aNdOrr76q6OhoPfjgg/L29pZ0Y0j0pk2bNGHCBLVo0cLFUeJu/Hkx9FajXooVK6b8Pm0aE8cBAABIXEjLI2bPnq2MjAz16dMn0+1nzpzRtGnTNGHChFyODFmRlpamcePGKS4uThaLxf5oSnp6ukwmk55++mkNGzaMu+n3kNjYWF27dk3PPfdcptsTExO1bNmyW36G8wOS9DyEpSnyHs5p/sBSIwAA3N6VK1e0Z88eh/8TRUZG2u+sA3kJSXoewNIUeQ/nNH9hqZG8hYsu96a0tDStW7fupjvptWvXVpMmTbhLBwDINSTpecDLL7+s8+fPa/z48bdcmqJ48eIsTXEP4ZzmLf+0lMj+/fvVuXNnkvQ8gosu955jx46pe/fuOn/+vGrWrOlwYXTnzp0qWbKk3n//fZUvX97FkeJOcdEl/2BodN7DOSVJzxNq166txYsX3zQj7Z/27Nmjzp07a8eOHbkcGbKKc5q3hIWF3dFSIyR19wYuuuQ93bp1U6FChfTWW2/dNHT2ypUrGjJkiK5fv66YmBgXRYi7wUWX/IULo3kP55TZ3fMElqbIezineQtLjeQtrO+a92zfvl3Lly/P9NlWb29v9evXT+3bt3dBZMiKUaNGqUqVKlqxYsUtL7q88cYbXHS5R+zfv/+22+Pj43MpEjgL5/SfkaTnASxNkfdwTvMWlhrJW7jokvcULVpUp06duu262kWLFs3lqJBVXHTJW1q3bi2DwZDp38k/y7kwem/hnP4zkvQ8IDo6WlarVf3797/l0hRDhw51cZS4G5zTvKVly5ZKTU295fbAwMB8/dzVvYaLLnlPu3btNHToUPXu3Vv/+te/FBgYKOnGc5G//PKLZs2apU6dOrk4StwpLrrkLT4+Pho8eLAefPDBTLcfPnxYL774Yi5HhezgnP4zkvQ8wMvLS6NHj9bgwYNZmiKP4JzmLf90x4Yk/d7CRZe8p1+/fipUqJDmzZuniRMn2u/g2Gw2BQYG6vnnn1ePHj1cHCXuFBdd8pbIyEidP39eZcqUyXT75cuXuTB6j+Gc/jMmjssjzGaz4uLiMp3FtE2bNvL393dxhLhbnNO8hfMJ3BtOnDjh8BktW7asiyNCVsydO1cffvihEhMTb7ro0qVLFy663EO++eYbpaSkqFWrVpluv3jxojZs2KCnnnoqlyNDVnFO/xlJeh6wa9cuPf/88ypYsKCioqIcZjHdtGmTrl27pnnz5ql69eoujhR3inOat3A+8x4uuuQvZ86c0bRp0zRhwgRXh4K7xEUXAPcikvQ8oH379goLC9Po0aNvmmTBZrNp5MiROnDggD7++GMXRYi7xTnNWzifeQsXXfIflgPKW7jokrdwPvMezilJep5Qo0YNffbZZ6pUqVKm248cOaKnnnpKu3btyuXIkFWc07yF85m3cNEl71m/fv1tt584cUJvvvkmSXoewUWXvIXzmfdwTpk4Lk8IDAzU7t27b5kA7N692z5pCu4NnNO8hfOZt+zfv18TJkzIdHkYg8GgLl265Ovn6O5FL7300i2XA/pTfl8O6F5yJxddcO/gfOY9nNN/RpKeB3Tv3l2vv/669uzZowcffNBhFtNNmzZp+fLlGjJkiIujxN3gnOYtnM+8hYsueU9QUJBGjhyppk2bZrp93759atOmTS5HhaziokvewvnMezin/4wkPQ/o2LGj/Pz8tGDBAi1dulQWi0WSZDKZFBERoQkTJqhZs2YujhJ3g3Oat3A+8xYuuuQ9ERER2rt37y2T9H/6zyTcCxdd8hbOZ97DOf1nJOl5RLNmzdSsWTOlp6crOTlZkuTn5ydPT08XR4as4pzmLZzPvIOLLnnP888/r5SUlFtuL1eunD788MNcjAjZwUWXvIXzmfdwTv8ZE8cBAJBFXHQB3M/WrVuVkpKihg0bZro9JSVFe/bs0QMPPJDLkSErOJ95D+f0n5GkAwAAAADgJoyuDgAAAAAAANxAkg4AAAAAgJsgSQcAAAAAwE2QpAMAAAAA4CZI0gEAyKdeffVV9e7d+673mz59ulq1apUDEQEAAJJ0AAAAAADcBEuwAQCQx61du1YzZ87UsWPHVKhQIYWHhys8PFwffPCBQ70PP/xQ9erV09tvv61169bp7NmzCgwMVMuWLfXSSy/J09NTn376qaKjox32mzBhgtq0aaNLly7pzTff1Pr165WWlqbIyEgNGzZMYWFhkqT9+/dr3Lhx2rNnjwwGgypUqKDRo0erevXqufZeAADg7jxcHQAAAMg558+f18CBAzV48GA1bdpUV69e1datW9W6dWudOXNGV65c0YQJEyRJPj4+kqQiRYpowoQJKl68uA4ePKjXX39dRYoUUY8ePdSsWTMdOnRIP/74o+bPny9JKlq0qCSpX79+KlCggN5//30VLVpUH3/8sbp06aKvvvpKvr6+GjRokMLDwzVq1CiZTCbt27dPnp6ernljAABwUyTpAADkYQkJCcrIyNCjjz6qMmXKSJKqVq0qSSpYsKDS0tIUFBTksM/fn1MPDg7WH3/8oS+//FI9evRQwYIFVbhwYZlMJof9tm7dql27dmnTpk3y8vKSJA0dOlTr1q3TV199pWeeeUanT59W9+7dValSJUlShQoVcrLrAADck0jSAQDIw8LCwvTggw+qZcuWql+/vurXr6/HH3/cftc8M6tXr9aHH36oEydOKCUlRRkZGfL29r7tcQ4cOKCUlBTVq1fPofzatWs6fvy4JKlbt2567bXX9PnnnysqKkpPPPGEypUrl/1OAgCQh5CkAwCQh5lMJs2fP1/bt2/XTz/9pEWLFmnKlCmKjY3NtP6OHTs0aNAg9e3bV/Xr11fRokX15Zdf2oe238rVq1cVFBSkRYsW3bTtz+Hwffv2VYsWLfT999/rhx9+0LRp0zRlyhQ9+uij2e8oAAB5BEk6AAB5nMFg0H333af77rtPL730kh555BGtW7dOnp6eslqtDnV37Nih0qVLq1evXvay06dPO9TJbL+IiAglJibKZDIpODj4lrFUrFhRFStWVNeuXTVgwADFxcWRpAMA8Dck6QAA5GE7d+7Upk2b9NBDDykgIEA7d+6U2WxWSEiIrl+/ro0bNyo+Pl6+vr4qWrSoypcvrzNnzujLL79U9erV9d1332ndunUObZYpU0YnT57Uvn37VKJECXl7eysqKkq1atXSSy+9pMGDB6tChQo6f/68vv/+ezVt2lSVK1fWW2+9pccff1zBwcE6e/asdu/erccee8xF7wwAAO6JJdgAAMjDjhw5ov9r745tDgqgMAx/+Ru1UFlCYwCVKZjCjZhAoVJYwwAm0AidKYREbhS3UvyJFZzieSY4Od1bfZvNJrfbLW3bZjQaZbFYZD6f5/F4pGmaXK/XvN/v7wTbdrvN4XBI13WZTqcZj8fZ7/c5n89Jkq7r0jRNTqdTXq/Xd4Ktbdvsdrscj8c8n88Mh8NMJpMsl8sMBoOs1+tcLpfc7/f0+/3MZrOsVqv0er0ffwkA6hDpAAAAUMTfrw8AAAAA/ol0AAAAKEKkAwAAQBEiHQAAAIoQ6QAAAFCESAcAAIAiRDoAAAAUIdIBAACgCJEOAAAARYh0AAAAKEKkAwAAQBEiHQAAAIr4ACm10TBc69cHAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1200x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df[\"mitigated_full\"] = np.around(mitigated / sum(mitigated), 3)\n",
    "\n",
    "ax = df.plot(\n",
    "    x=\"states\",\n",
    "    y=[\"noisy\", \"mitigated_k_local\", \"mitigated_full\"],\n",
    "    kind=\"bar\",\n",
    "    figsize=(12, 5),\n",
    ")\n",
    "ax.bar_label(ax.containers[0], labels=df[\"noisy\"])\n",
    "ax.bar_label(ax.containers[1], labels=df[\"mitigated_k_local\"])\n",
    "ax.bar_label(ax.containers[2], labels=df[\"mitigated_full\"])\n",
    "ax.set_ylabel(\"probabilities\")\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
